//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       AMT_AuditLog.cs
//
//  Contents:   Represents an Audit Log
//              This file was automatically generated from AMT_AuditLog.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>
	///Represents an Audit Log
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog")]
	[System.Xml.Serialization.XmlRootAttribute("AMT_AuditLog", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
	public class AMT_AuditLog : CIM_Log
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public AMT_AuditLog() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public AMT_AuditLog(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_AuditLog(IWSManClient client): base(client)
		{
		}


		/// <summary>
		/// Required, State of log. A bitwise combination of one or more of: 0x00 (Enabled), 0x01 (Disabled), 0x02 (Locked), 0x04 (Almost Full - The storage area dedicated for the audit log reached 85% full, and non-critical events will not be logged.), 0x08 (Full - The storage area dedicated for the audit log is completely full; no events will be logged and critical events in policy will not be executed.), 0x10 (No Key - No key and certificate were set for the signing of the audit log. Feature cannot be enabled).
		/// </summary>
		[CimField(false, true)]
		public virtual uint AuditState
		{
			get
			{
					return uint.Parse(this["AuditState"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("AuditState",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Required, Maximum number of auditors allowed
		/// </summary>
		[CimField(false, true)]
		public virtual ushort MaxAllowedAuditors
		{
			get
			{
					return ushort.Parse(this["MaxAllowedAuditors"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("MaxAllowedAuditors",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove MinDaysToKeep field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveMinDaysToKeep()
		{
			RemoveField("MinDaysToKeep");
		}

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

		/// <summary>
		/// Optional, Minimum number of days to keep records in the AuditLog. Relevant only if "storagePolicy" is set to "RESTRICTED_ROLL_OVER".
		/// </summary>
		[CimField(false, false)]
		public virtual byte MinDaysToKeep
		{
			get
			{
					return byte.Parse(this["MinDaysToKeep"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("MinDaysToKeep",value.ToString(CultureInfo.InvariantCulture));
			}
		}


		/// <summary>
		/// Key, Required, 
		/// </summary>
		[CimField(true, true)]
		public override string Name
		{
			get
			{
				return this.GetField("Name")[0];
			}
			set
			{
			this.SetOrAddField("Name",value);
			}
		}


		/// <summary>
		/// Required, Indicates the percentage of free space in the storage dedicated to the audit log.
		/// </summary>
		[CimField(false, true)]
		public virtual uint PercentageFree
		{
			get
			{
					return uint.Parse(this["PercentageFree"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PercentageFree",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove StoragePolicy field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveStoragePolicy()
		{
			RemoveField("StoragePolicy");
		}

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

		/// <summary>
		/// Optional, AuditLog storage policy. The available policies are: "NO_ROLL_OVER" - No roll-over in storage. Old events will not be overwritten. "ROLL_OVER" - Full rollover. Any old record will be overwritten. "RESTRICTED_ROLL_OVER" - Parital (restricted) rollover. Only old events (under certain threshold, which can be set using SetStoragePolicy) will be overwritten. If not specified default is "ROLL_OVER" unless FW was upgraded from AMT 5.0 and then "NO_ROLL_OVER" will be used as default.
		/// </summary>
		[CimField(false, false)]
		public virtual byte StoragePolicy
		{
			get
			{
					return byte.Parse(this["StoragePolicy"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("StoragePolicy",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove TimeOfLastRecord field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveTimeOfLastRecord()
		{
			RemoveField("TimeOfLastRecord");
		}

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

		/// <summary>
		/// Optional, Time stamp of the most recent entry in the log if such an entry exists.
		/// </summary>
		[CimField(false, false)]
		public virtual CimDateTime TimeOfLastRecord
		{
			get
			{
					return CimDateTime.Parse(this["TimeOfLastRecord"][0]);
			}
			set
			{
				this.SetOrAddField("TimeOfLastRecord",value.ToString());
			}
		}
		/// <summary>
		///Returns a list of consecutive audit log records in chronological order: The first record in the returned array is the oldest record stored in the log . The record entries are returned as an array of base64Binary elements. Each record holds the following information: uint16 AuditAppID -A unique ID for each auditable application. uint16 EventID -ID of an event of the application. uint8 InitiatorType -0 (HTTP Digest username), 1 (Kerberos SID), 2 (Local). See below InitiatorData -See below. uint32 TimeStamp -Time when the event occurred in seconds since 1.1.1970. uint8 MCLocationType -0 (IPv4 Address), 1 (IPv6 Address), 2 (None). uint8 NetAddressLength -Length of the NetAddress field. Array of uint8 NetAddress	 -ASCII representation of the network address of management console or Local Host IP (e.g. 127.0.0.1). Note: In Intel AMT Release 4.0 IP address representation includes null-terminator and NetAddressLength includes the null terminator. uint8 ExtendedDataLength -Length of event specific data. Array of uint8 ExtendedData -Event specific data. 
		///The InitiatorData field may hold different data types according to the InitiatorType field: HTTP digest initiator: In Intel AMT Release 4.0 data for username includes null terminator and UsernameLength includes the null terminator. uint8 UsernameLength Array of uint8 Username Kerberos SID initiator: uint32 UserInDomain uint8 DomainLength Array of uint8 Domain Local: Empty.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
		private class ReadRecords_INPUT : CimParams
		{
			public ReadRecords_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Identifies the position of the first record to retrieve. An index of 1 indicates the first record in the log.
			/// </summary>
			[CimField(false,true)]
			public virtual uint StartIndex
			{
				set
				{
					this.SetOrAddField("StartIndex",value.ToString(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///Returns a list of consecutive audit log records in chronological order: The first record in the returned array is the oldest record stored in the log . The record entries are returned as an array of base64Binary elements. Each record holds the following information: uint16 AuditAppID -A unique ID for each auditable application. uint16 EventID -ID of an event of the application. uint8 InitiatorType -0 (HTTP Digest username), 1 (Kerberos SID), 2 (Local). See below InitiatorData -See below. uint32 TimeStamp -Time when the event occurred in seconds since 1.1.1970. uint8 MCLocationType -0 (IPv4 Address), 1 (IPv6 Address), 2 (None). uint8 NetAddressLength -Length of the NetAddress field. Array of uint8 NetAddress	 -ASCII representation of the network address of management console or Local Host IP (e.g. 127.0.0.1). Note: In Intel AMT Release 4.0 IP address representation includes null-terminator and NetAddressLength includes the null terminator. uint8 ExtendedDataLength -Length of event specific data. Array of uint8 ExtendedData -Event specific data. 
		///The InitiatorData field may hold different data types according to the InitiatorType field: HTTP digest initiator: In Intel AMT Release 4.0 data for username includes null terminator and UsernameLength includes the null terminator. uint8 UsernameLength Array of uint8 Username Kerberos SID initiator: uint32 UserInDomain uint8 DomainLength Array of uint8 Domain Local: Empty.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
		private class ReadRecords_OUTPUT : CimParams
		{
			public ReadRecords_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, The total number of records in the log.
			/// </summary>
			[CimField(false,false)]
			public virtual uint TotalRecordCount
			{
				get
				{
						return uint.Parse(this["TotalRecordCount"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, The number of records returned + content of 10 records from the start index. 
			/// </summary>
			[CimField(false,false)]
			public virtual uint RecordsReturned
			{
				get
				{
						return uint.Parse(this["RecordsReturned"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, Notice: the values of this array are actually base64 encoded values. A list of event records.
			/// </summary>
			[CimField(false,false)]
			public virtual string[] EventRecords
			{
				get
				{
					return this["EventRecords"];
				}
			}
		}
		/// <summary>
		///Returns a list of consecutive audit log records in chronological order: The first record in the returned array is the oldest record stored in the log . The record entries are returned as an array of base64Binary elements. Each record holds the following information: uint16 AuditAppID -A unique ID for each auditable application. uint16 EventID -ID of an event of the application. uint8 InitiatorType -0 (HTTP Digest username), 1 (Kerberos SID), 2 (Local). See below InitiatorData -See below. uint32 TimeStamp -Time when the event occurred in seconds since 1.1.1970. uint8 MCLocationType -0 (IPv4 Address), 1 (IPv6 Address), 2 (None). uint8 NetAddressLength -Length of the NetAddress field. Array of uint8 NetAddress	 -ASCII representation of the network address of management console or Local Host IP (e.g. 127.0.0.1). Note: In Intel AMT Release 4.0 IP address representation includes null-terminator and NetAddressLength includes the null terminator. uint8 ExtendedDataLength -Length of event specific data. Array of uint8 ExtendedData -Event specific data. 
		///The InitiatorData field may hold different data types according to the InitiatorType field: HTTP digest initiator: In Intel AMT Release 4.0 data for username includes null terminator and UsernameLength includes the null terminator. uint8 UsernameLength Array of uint8 Username Kerberos SID initiator: uint32 UserInDomain uint8 DomainLength Array of uint8 Domain Local: Empty.
		/// </summary>
		/// <param name="inStartIndex">Required, IN -Identifies the position of the first record to retrieve. An index of 1 indicates the first record in the log.</param>
		/// <param name="outTotalRecordCount">OUT - The total number of records in the log.</param>
		/// <param name="outRecordsReturned">OUT - The number of records returned + content of 10 records from the start index. </param>
		/// <param name="outEventRecords">OUT - Notice: the values of this array are actually base64 encoded values. A list of event records.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_NOT_READY : 2
		/// PT_STATUS_INVALID_INDEX : 35
		/// </returns>
		public virtual uint ReadRecords(uint? inStartIndex,out uint outTotalRecordCount,out uint outRecordsReturned,out string[] outEventRecords)
		{
			ReadRecords_INPUT input = new ReadRecords_INPUT(this.XmlNamespace);
			if (inStartIndex.HasValue)
				input.StartIndex=inStartIndex.Value;
			ReadRecords_OUTPUT output = new ReadRecords_OUTPUT();
			uint returnValue = base.Invoke("ReadRecords",input,out output);
			outTotalRecordCount=0;
			outRecordsReturned=0;
			outEventRecords=null;
			if (returnValue == 0)
			{
				if (output.ContainsField("TotalRecordCount"))
					outTotalRecordCount = output.TotalRecordCount;
				if (output.ContainsField("RecordsReturned"))
					outRecordsReturned = output.RecordsReturned;
				if (output.ContainsField("EventRecords"))
					outEventRecords = output.EventRecords;
			}
			return returnValue;
		}
		/// <summary>
		///This method is used by an auditor to stop the system from logging any records while exporting and clearing the log. It performs lock, unlock or allows unprovisioning of the system. When the audit log is locked, no events are written into the log. Any events marked in the policy as critical will not be executed. If the log is locked and another lock is requested with the same handle, so the timeout will be renewed with the new LockTimeoutInSeconds.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
		private class SetAuditLock_INPUT : CimParams
		{
			public SetAuditLock_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Optional, The maximum number of seconds that the audit log will be locked in case for some reason the auditor fails to unlock the log. Max value is 5 minutes. This parameter is required when the flag parameter has a value of AUDIT_LOG_LOCK, or UNPROVISIONING_LOCK. This parameter is not required and is ignored when AUDIT_LOG_UNLOCK flag is used.
			/// </summary>
			[CimField(false,false)]
			public virtual uint LockTimeoutInSeconds
			{
				set
				{
					this.SetOrAddField("LockTimeoutInSeconds",value.ToString(CultureInfo.InvariantCulture));
				}
			}
			/// <summary>
			/// Required, Defines the locking action.
			/// </summary>
			[CimField(false,true)]
			public virtual uint Flag
			{
				set
				{
					this.SetOrAddField("Flag",value.ToString(CultureInfo.InvariantCulture));
				}
			}
			/// <summary>
			/// Optional, A handle is received when locking the log. As long as the log is locked, lock and unlock requests can be performed only by using the same handle. If the log is not locked so Handle-IN is not required and is ignored. Handle-OUT is not supplied when SetAuditLock failed to lock the audit log or when unlock is preformed.
			/// </summary>
			[CimField(false,false)]
			public virtual uint Handle
			{
				set
				{
					this.SetOrAddField("Handle",value.ToString(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///This method is used by an auditor to stop the system from logging any records while exporting and clearing the log. It performs lock, unlock or allows unprovisioning of the system. When the audit log is locked, no events are written into the log. Any events marked in the policy as critical will not be executed. If the log is locked and another lock is requested with the same handle, so the timeout will be renewed with the new LockTimeoutInSeconds.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
		private class SetAuditLock_OUTPUT : CimParams
		{
			public SetAuditLock_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, A handle is received when locking the log. As long as the log is locked, lock and unlock requests can be performed only by using the same handle. If the log is not locked so Handle-IN is not required and is ignored. Handle-OUT is not supplied when SetAuditLock failed to lock the audit log or when unlock is preformed.
			/// </summary>
			[CimField(false,false)]
			public virtual uint Handle
			{
				get
				{
						return uint.Parse(this["Handle"][0], CultureInfo.InvariantCulture);
				}
			}
		}
		/// <summary>
		///This method is used by an auditor to stop the system from logging any records while exporting and clearing the log. It performs lock, unlock or allows unprovisioning of the system. When the audit log is locked, no events are written into the log. Any events marked in the policy as critical will not be executed. If the log is locked and another lock is requested with the same handle, so the timeout will be renewed with the new LockTimeoutInSeconds.
		/// </summary>
		/// <param name="inLockTimeoutInSeconds">Optional, IN -The maximum number of seconds that the audit log will be locked in case for some reason the auditor fails to unlock the log. Max value is 5 minutes. This parameter is required when the flag parameter has a value of AUDIT_LOG_LOCK, or UNPROVISIONING_LOCK. This parameter is not required and is ignored when AUDIT_LOG_UNLOCK flag is used.</param>
		/// <param name="inFlag">Required, IN -Defines the locking action.</param>
		/// <param name="inHandle">Optional, IN -A handle is received when locking the log. As long as the log is locked, lock and unlock requests can be performed only by using the same handle. If the log is not locked so Handle-IN is not required and is ignored. Handle-OUT is not supplied when SetAuditLock failed to lock the audit log or when unlock is preformed.</param>
		/// <param name="outHandle">OUT - A handle is received when locking the log. As long as the log is locked, lock and unlock requests can be performed only by using the same handle. If the log is not locked so Handle-IN is not required and is ignored. Handle-OUT is not supplied when SetAuditLock failed to lock the audit log or when unlock is preformed.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_NOT_READY : 2
		/// PT_STATUS_NOT_PERMITTED : 16
		/// PT_STATUS_INVALID_PARAMETER : 36
		/// PT_STATUS_INVALID_HANDLE : 2053
		/// </returns>
		public virtual uint SetAuditLock(uint? inLockTimeoutInSeconds,uint? inFlag,uint? inHandle,out uint outHandle)
		{
			SetAuditLock_INPUT input = new SetAuditLock_INPUT(this.XmlNamespace);
			if (inLockTimeoutInSeconds.HasValue)
				input.LockTimeoutInSeconds=inLockTimeoutInSeconds.Value;
			if (inFlag.HasValue)
				input.Flag=inFlag.Value;
			if (inHandle.HasValue)
				input.Handle=inHandle.Value;
			SetAuditLock_OUTPUT output = new SetAuditLock_OUTPUT();
			uint returnValue = base.Invoke("SetAuditLock",input,out output);
			outHandle=0;
			if (returnValue == 0)
			{
				if (output.ContainsField("Handle"))
					outHandle = output.Handle;
			}
			return returnValue;
		}
		/// <summary>
		///Returns the audit log signature and log related information.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
		private class ExportAuditLogSignature_INPUT : CimParams
		{
			public ExportAuditLogSignature_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Signing Mechanism
			/// </summary>
			[CimField(false,true)]
			public virtual uint SigningMechanism
			{
				set
				{
					this.SetOrAddField("SigningMechanism",value.ToString(CultureInfo.InvariantCulture));
				}
			}
		}
		/// <summary>
		///Returns the audit log signature and log related information.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
		private class ExportAuditLogSignature_OUTPUT : CimParams
		{
			public ExportAuditLogSignature_OUTPUT() : base("")
			{
			}

			/// <summary>
			/// Optional, The total number of event records in the event log.
			/// </summary>
			[CimField(false,false)]
			public virtual uint TotalRecordCount
			{
				get
				{
						return uint.Parse(this["TotalRecordCount"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, Time stamp of the first record.
			/// </summary>
			[CimField(false,false)]
			public virtual CimDateTime StartLogTime
			{
				get
				{
						return CimDateTime.Parse(this["StartLogTime"][0]);
				}
			}
			/// <summary>
			/// Optional, Time stamp of the last record.
			/// </summary>
			[CimField(false,false)]
			public virtual CimDateTime EndLogTime
			{
				get
				{
						return CimDateTime.Parse(this["EndLogTime"][0]);
				}
			}
			/// <summary>
			/// Optional, Time stamp indicating when was the signature generated.
			/// </summary>
			[CimField(false,false)]
			public virtual CimDateTime GenerationTime
			{
				get
				{
						return CimDateTime.Parse(this["GenerationTime"][0]);
				}
			}
			/// <summary>
			/// Optional, UUID of the current system for identifying it in the audit repository.
			/// </summary>
			[CimField(false,false)]
			public virtual string UUID
			{
				get
				{
					return this.GetField("UUID")[0];
				}
			}
			/// <summary>
			/// Optional, FQDN of the system.
			/// </summary>
			[CimField(false,false)]
			public virtual string FQDN
			{
				get
				{
					return this.GetField("FQDN")[0];
				}
			}
			/// <summary>
			/// Optional, Signature mechanism.
			/// </summary>
			[CimField(false,false)]
			public virtual uint SignatureMechanism
			{
				get
				{
						return uint.Parse(this["SignatureMechanism"][0], CultureInfo.InvariantCulture);
				}
			}
			/// <summary>
			/// Optional, The audit log signature, 1024 bytes long.
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] Signature
			{
				get
				{
						return Convert.FromBase64String(this.GetField("Signature")[0]);				}
			}
			/// <summary>
			/// Optional, An array specifying the length of each certificate.
			/// </summary>
			[CimField(false,false)]
			public virtual ushort[] LengthOfCertificates
			{
				get
				{
					string[] arr = this["LengthOfCertificates"];
					List<ushort> newArr = new List<ushort>();
					foreach (string str in arr)
					{
						newArr.Add(ushort.Parse(str, CultureInfo.InvariantCulture));
					}
					return newArr.ToArray();
				}
			}
			/// <summary>
			/// Optional, The certificates, cascaded into one stream.
			/// </summary>
			[CimField(false,false)]
			public virtual byte[] Certificates
			{
				get
				{
						return Convert.FromBase64String(this.GetField("Certificates")[0]);				}
			}
		}
		/// <summary>
		///Returns the audit log signature and log related information.
		/// </summary>
		/// <param name="inSigningMechanism">Required, IN -Signing Mechanism</param>
		/// <param name="outTotalRecordCount">OUT - The total number of event records in the event log.</param>
		/// <param name="outStartLogTime">OUT - Time stamp of the first record.</param>
		/// <param name="outEndLogTime">OUT - Time stamp of the last record.</param>
		/// <param name="outGenerationTime">OUT - Time stamp indicating when was the signature generated.</param>
		/// <param name="outUUID">OUT - UUID of the current system for identifying it in the audit repository.</param>
		/// <param name="outFQDN">OUT - FQDN of the system.</param>
		/// <param name="outSignatureMechanism">OUT - Signature mechanism.</param>
		/// <param name="outSignature">OUT - The audit log signature, 1024 bytes long.</param>
		/// <param name="outLengthOfCertificates">OUT - An array specifying the length of each certificate.</param>
		/// <param name="outCertificates">OUT - The certificates, cascaded into one stream.</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_INTERNAL_ERROR : 1
		/// PT_STATUS_NOT_READY : 2
		/// PT_STATUS_NOT_PERMITTED : 16
		/// PT_STATUS_UNSUPPORTED : 2066
		/// </returns>
		public virtual uint ExportAuditLogSignature(uint? inSigningMechanism,out uint outTotalRecordCount,out CimDateTime outStartLogTime,out CimDateTime outEndLogTime,out CimDateTime outGenerationTime,out string outUUID,out string outFQDN,out uint outSignatureMechanism,out byte[] outSignature,out ushort[] outLengthOfCertificates,out byte[] outCertificates)
		{
			ExportAuditLogSignature_INPUT input = new ExportAuditLogSignature_INPUT(this.XmlNamespace);
			if (inSigningMechanism.HasValue)
				input.SigningMechanism=inSigningMechanism.Value;
			ExportAuditLogSignature_OUTPUT output = new ExportAuditLogSignature_OUTPUT();
			uint returnValue = base.Invoke("ExportAuditLogSignature",input,out output);
			outTotalRecordCount=0;
			outStartLogTime=null;
			outEndLogTime=null;
			outGenerationTime=null;
			outUUID=null;
			outFQDN=null;
			outSignatureMechanism=0;
			outSignature=null;
			outLengthOfCertificates=null;
			outCertificates=null;
			if (returnValue == 0)
			{
				if (output.ContainsField("TotalRecordCount"))
					outTotalRecordCount = output.TotalRecordCount;
				if (output.ContainsField("StartLogTime"))
					outStartLogTime = output.StartLogTime;
				if (output.ContainsField("EndLogTime"))
					outEndLogTime = output.EndLogTime;
				if (output.ContainsField("GenerationTime"))
					outGenerationTime = output.GenerationTime;
				if (output.ContainsField("UUID"))
					outUUID = output.UUID;
				if (output.ContainsField("FQDN"))
					outFQDN = output.FQDN;
				if (output.ContainsField("SignatureMechanism"))
					outSignatureMechanism = output.SignatureMechanism;
				if (output.ContainsField("Signature"))
					outSignature = output.Signature;
				if (output.ContainsField("LengthOfCertificates"))
					outLengthOfCertificates = output.LengthOfCertificates;
				if (output.ContainsField("Certificates"))
					outCertificates = output.Certificates;
			}
			return returnValue;
		}
		/// <summary>
		///Sets the key and certificates needed for the signing of the audit log. This method must be called before enabling the audit log.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
		private class SetSigningKeyMaterial_INPUT : CimParams
		{
			public SetSigningKeyMaterial_INPUT(string ns) : base(ns)
			{
			}

			/// <summary>
			/// Required, Audit data signing mechanism type.
			/// </summary>
			[CimField(false,true)]
			public virtual uint SigningMechanismType
			{
				set
				{
					this.SetOrAddField("SigningMechanismType",value.ToString(CultureInfo.InvariantCulture));
				}
			}
			/// <summary>
			/// Required, Key pair (RSA 2048 bit modulus).
			/// </summary>
			[CimField(false,true)]
			public virtual byte[] SigningKey
			{
				set
				{
				this.SetOrAddField("SigningKey",Convert.ToBase64String(value));
				}
			}
			/// <summary>
			/// Required, An array specifying the length of each certificate.
			/// </summary>
			[CimField(false,true)]
			public virtual ushort[] LengthOfCertificates
			{
				set
				{
					List<string> newArr = new List<string>();
					foreach (ushort val in value)
					{
						newArr.Add(val.ToString(CultureInfo.InvariantCulture));
					}
					this.SetOrAddField("LengthOfCertificates",newArr.ToArray());
				}
			}
			/// <summary>
			/// Required, Up to 5 certificates cascaded into one stream (with a total length of 4100 bytes).
			/// </summary>
			[CimField(false,true)]
			public virtual byte[] Certificates
			{
				set
				{
				this.SetOrAddField("Certificates",Convert.ToBase64String(value));
				}
			}
		}
		/// <summary>
		///Sets the key and certificates needed for the signing of the audit log. This method must be called before enabling the audit log.
		/// </summary>
		[System.SerializableAttribute()]
		[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
		[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_AuditLog", IsNullable=false)]
		private class SetSigningKeyMaterial_OUTPUT : CimParams
		{
			public SetSigningKeyMaterial_OUTPUT() : base("")
			{
			}

		}
		/// <summary>
		///Sets the key and certificates needed for the signing of the audit log. This method must be called before enabling the audit log.
		/// </summary>
		/// <param name="inSigningMechanismType">Required, IN -Audit data signing mechanism type.</param>
		/// <param name="inSigningKey">Required, IN -Key pair (RSA 2048 bit modulus).</param>
		/// <param name="inLengthOfCertificates">Required, IN -An array specifying the length of each certificate.</param>
		/// <param name="inCertificates">Required, IN -Up to 5 certificates cascaded into one stream (with a total length of 4100 bytes).</param>
		/// <returns>
		/// Legal values:
		/// PT_STATUS_SUCCESS : 0
		/// PT_STATUS_INTERNAL_ERROR : 1
		/// PT_STATUS_NOT_READY : 2
		/// PT_STATUS_INVALID_PARAMETER : 36
		/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
		/// PT_STATUS_INVALID_KEY : 2062
		/// PT_STATUS_INVALID_CERT : 2063
		/// PT_STATUS_CERT_KEY_NOT_MATCH : 2064
		/// PT_STATUS_UNSUPPORTED : 2066
		/// </returns>
		public virtual uint SetSigningKeyMaterial(uint? inSigningMechanismType,byte[] inSigningKey,ushort[] inLengthOfCertificates,byte[] inCertificates)
		{
			SetSigningKeyMaterial_INPUT input = new SetSigningKeyMaterial_INPUT(this.XmlNamespace);
			if (inSigningMechanismType.HasValue)
				input.SigningMechanismType=inSigningMechanismType.Value;
			if (inSigningKey != null)
				input.SigningKey=inSigningKey;
			if (inLengthOfCertificates != null)
				input.LengthOfCertificates=inLengthOfCertificates;
			if (inCertificates != null)
				input.Certificates=inCertificates;
			SetSigningKeyMaterial_OUTPUT output = new SetSigningKeyMaterial_OUTPUT();
			uint returnValue = base.Invoke("SetSigningKeyMaterial",input,out output);
			return returnValue;
		}

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

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


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


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

		public new class CimKeys : CIM_Log.CimKeys
		{
			/// <summary>
			/// Key, Required, 
			/// </summary>

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

	}
}