Silverlight 5

WinRT

	public sealed enum AccessControlActions
	: IComparable, IFormattable, IConvertible
	{ None, View, Change }

	public sealed enum AccessControlModification
	: IComparable, IFormattable, IConvertible
	{ Add, Set, Reset, Remove, RemoveAll, RemoveSpecific }

	public sealed enum AccessControlSections
	: IComparable, IFormattable, IConvertible
	{ None, Audit, Access, Owner, Group, All }

	public sealed enum AccessControlType
	: IComparable, IFormattable, IConvertible
	{ Allow, Deny }

	public abstract class AccessRule
	: AuthorizationRule
	public AccessControlType AccessControlType { get; }

	public class AccessRule`1<T>
	: AccessRule where T : ValueType
	public T Rights { get; }

	public sealed class AceEnumerator
	: IEnumerator
	public GenericAce Current { get; }
	public virtual Boolean MoveNext();
	public virtual void Reset();

	public sealed enum AceFlags
	: IComparable, IFormattable, IConvertible
	{ None, ObjectInherit, ContainerInherit, NoPropagateInherit, InheritOnly, Inherited, SuccessfulAccess, FailedAccess, InheritanceFlags, AuditFlags }

	public sealed enum AceQualifier
	: IComparable, IFormattable, IConvertible
	{ AccessAllowed, AccessDenied, SystemAudit, SystemAlarm }

	public sealed enum AceType
	: IComparable, IFormattable, IConvertible
	{ AccessAllowed, AccessDenied, SystemAudit, SystemAlarm, AccessAllowedCompound, AccessAllowedObject, AccessDeniedObject, SystemAuditObject, SystemAlarmObject, AccessAllowedCallback, AccessDeniedCallback, AccessAllowedCallbackObject, AccessDeniedCallbackObject, SystemAuditCallback, SystemAlarmCallback, SystemAuditCallbackObject, SystemAlarmCallbackObject, MaxDefinedAceType }

	public sealed enum AuditFlags
	: IComparable, IFormattable, IConvertible
	{ None, Success, Failure }

	public abstract class AuditRule
	: AuthorizationRule
	public AuditFlags AuditFlags { get; }

	public class AuditRule`1<T>
	: AuditRule where T : ValueType
	public T Rights { get; }

	public abstract class AuthorizationRule
	internal protected Int32 AccessMask { get; }
	public IdentityReference IdentityReference { get; }
	public InheritanceFlags InheritanceFlags { get; }
	public Boolean IsInherited { get; }
	public PropagationFlags PropagationFlags { get; }

	public sealed class AuthorizationRuleCollection
	: ReadOnlyCollectionBase, ICollection, IEnumerable
	public AuthorizationRule Item { get; }
	public void CopyTo(AuthorizationRule rules, Int32 index);

	public sealed class CommonAce
	: QualifiedAce
	public virtual Int32 BinaryLength { get; }
	public virtual void GetBinaryForm(Byte binaryForm, Int32 offset);
	static public Int32 MaxOpaqueLength(Boolean isCallback);

	public abstract class CommonAcl
	: GenericAcl, ICollection, IEnumerable
	public virtual Int32 BinaryLength { get; }
	public virtual Int32 Count { get; }
	public Boolean IsCanonical { get; }
	public Boolean IsContainer { get; }
	public Boolean IsDS { get; }
	public virtual GenericAce Item { get; set; }
	public virtual Byte Revision { get; }
	public virtual void GetBinaryForm(Byte binaryForm, Int32 offset);
	public void Purge(SecurityIdentifier sid);
	public void RemoveInheritedAces();

	public abstract class CommonObjectSecurity
	: ObjectSecurity
	protected void AddAccessRule(AccessRule rule);
	protected void AddAuditRule(AuditRule rule);
	public AuthorizationRuleCollection GetAccessRules(Boolean includeExplicit, Boolean includeInherited, Type targetType);
	public AuthorizationRuleCollection GetAuditRules(Boolean includeExplicit, Boolean includeInherited, Type targetType);
	protected virtual Boolean ModifyAccess(AccessControlModification modification, AccessRule rule, out Boolean& modified);
	protected virtual Boolean ModifyAudit(AccessControlModification modification, AuditRule rule, out Boolean& modified);
	protected Boolean RemoveAccessRule(AccessRule rule);
	protected void RemoveAccessRuleAll(AccessRule rule);
	protected void RemoveAccessRuleSpecific(AccessRule rule);
	protected Boolean RemoveAuditRule(AuditRule rule);
	protected void RemoveAuditRuleAll(AuditRule rule);
	protected void RemoveAuditRuleSpecific(AuditRule rule);
	protected void ResetAccessRule(AccessRule rule);
	protected void SetAccessRule(AccessRule rule);
	protected void SetAuditRule(AuditRule rule);

	public sealed class CommonSecurityDescriptor
	: GenericSecurityDescriptor
	public virtual ControlFlags ControlFlags { get; }
	public DiscretionaryAcl DiscretionaryAcl { get; set; }
	public virtual SecurityIdentifier Group { get; set; }
	public Boolean IsContainer { get; }
	public Boolean IsDiscretionaryAclCanonical { get; }
	public Boolean IsDS { get; }
	public Boolean IsSystemAclCanonical { get; }
	public virtual SecurityIdentifier Owner { get; set; }
	public SystemAcl SystemAcl { get; set; }
	public void PurgeAccessControl(SecurityIdentifier sid);
	public void PurgeAudit(SecurityIdentifier sid);
	public void SetDiscretionaryAclProtection(Boolean isProtected, Boolean preserveInheritance);
	public void SetSystemAclProtection(Boolean isProtected, Boolean preserveInheritance);

	public sealed class CompoundAce
	: KnownAce
	public virtual Int32 BinaryLength { get; }
	public CompoundAceType CompoundAceType { get; set; }
	public virtual void GetBinaryForm(Byte binaryForm, Int32 offset);

	public sealed enum CompoundAceType
	: IComparable, IFormattable, IConvertible
	{ Impersonation }

	public sealed enum ControlFlags
	: IComparable, IFormattable, IConvertible
	{ None, OwnerDefaulted, GroupDefaulted, DiscretionaryAclPresent, DiscretionaryAclDefaulted, SystemAclPresent, SystemAclDefaulted, DiscretionaryAclUntrusted, ServerSecurity, DiscretionaryAclAutoInheritRequired, SystemAclAutoInheritRequired, DiscretionaryAclAutoInherited, SystemAclAutoInherited, DiscretionaryAclProtected, SystemAclProtected, RMControlValid, SelfRelative }

	public sealed class CryptoKeyAccessRule
	: AccessRule
	public CryptoKeyRights CryptoKeyRights { get; }

	public sealed class CryptoKeyAuditRule
	: AuditRule
	public CryptoKeyRights CryptoKeyRights { get; }

	public sealed enum CryptoKeyRights
	: IComparable, IFormattable, IConvertible
	{ ReadData, WriteData, ReadExtendedAttributes, WriteExtendedAttributes, ReadAttributes, WriteAttributes, Delete, ReadPermissions, ChangePermissions, TakeOwnership, Synchronize, FullControl, GenericAll, GenericExecute, GenericWrite, GenericRead }

	public sealed class CryptoKeySecurity
	: NativeObjectSecurity
	public virtual Type AccessRightType { get; }
	public virtual Type AccessRuleType { get; }
	public virtual Type AuditRuleType { get; }
	public virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
	public void AddAccessRule(CryptoKeyAccessRule rule);
	public void AddAuditRule(CryptoKeyAuditRule rule);
	public virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
	public Boolean RemoveAccessRule(CryptoKeyAccessRule rule);
	public void RemoveAccessRuleAll(CryptoKeyAccessRule rule);
	public void RemoveAccessRuleSpecific(CryptoKeyAccessRule rule);
	public Boolean RemoveAuditRule(CryptoKeyAuditRule rule);
	public void RemoveAuditRuleAll(CryptoKeyAuditRule rule);
	public void RemoveAuditRuleSpecific(CryptoKeyAuditRule rule);
	public void ResetAccessRule(CryptoKeyAccessRule rule);
	public void SetAccessRule(CryptoKeyAccessRule rule);
	public void SetAuditRule(CryptoKeyAuditRule rule);

	public sealed class CustomAce
	: GenericAce
	public virtual Int32 BinaryLength { get; }
	public Int32 OpaqueLength { get; }
	public virtual void GetBinaryForm(Byte binaryForm, Int32 offset);
	public Byte GetOpaque();
	public void SetOpaque(Byte opaque);

	public abstract class DirectoryObjectSecurity
	: ObjectSecurity
	public virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type, Guid objectType, Guid inheritedObjectType);
	protected void AddAccessRule(ObjectAccessRule rule);
	protected void AddAuditRule(ObjectAuditRule rule);
	public virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags, Guid objectType, Guid inheritedObjectType);
	public AuthorizationRuleCollection GetAccessRules(Boolean includeExplicit, Boolean includeInherited, Type targetType);
	public AuthorizationRuleCollection GetAuditRules(Boolean includeExplicit, Boolean includeInherited, Type targetType);
	protected virtual Boolean ModifyAccess(AccessControlModification modification, AccessRule rule, out Boolean& modified);
	protected virtual Boolean ModifyAudit(AccessControlModification modification, AuditRule rule, out Boolean& modified);
	protected Boolean RemoveAccessRule(ObjectAccessRule rule);
	protected void RemoveAccessRuleAll(ObjectAccessRule rule);
	protected void RemoveAccessRuleSpecific(ObjectAccessRule rule);
	protected Boolean RemoveAuditRule(ObjectAuditRule rule);
	protected void RemoveAuditRuleAll(ObjectAuditRule rule);
	protected void RemoveAuditRuleSpecific(ObjectAuditRule rule);
	protected void ResetAccessRule(ObjectAccessRule rule);
	protected void SetAccessRule(ObjectAccessRule rule);
	protected void SetAuditRule(ObjectAuditRule rule);

	public sealed class DirectorySecurity
	: FileSystemSecurity

	public sealed class DiscretionaryAcl
	: CommonAcl, ICollection, IEnumerable
	public void AddAccess(AccessControlType accessType, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags);
	public void AddAccess(AccessControlType accessType, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType);
	public Boolean RemoveAccess(AccessControlType accessType, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags);
	public Boolean RemoveAccess(AccessControlType accessType, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType);
	public void RemoveAccessSpecific(AccessControlType accessType, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags);
	public void RemoveAccessSpecific(AccessControlType accessType, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType);
	public void SetAccess(AccessControlType accessType, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags);
	public void SetAccess(AccessControlType accessType, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType);

	public sealed class EventWaitHandleAccessRule
	: AccessRule
	public EventWaitHandleRights EventWaitHandleRights { get; }

	public sealed class EventWaitHandleAuditRule
	: AuditRule
	public EventWaitHandleRights EventWaitHandleRights { get; }

	public sealed enum EventWaitHandleRights
	: IComparable, IFormattable, IConvertible
	{ Modify, Delete, ReadPermissions, ChangePermissions, TakeOwnership, Synchronize, FullControl }

	public sealed class EventWaitHandleSecurity
	: NativeObjectSecurity
	public virtual Type AccessRightType { get; }
	public virtual Type AccessRuleType { get; }
	public virtual Type AuditRuleType { get; }
	public virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
	public void AddAccessRule(EventWaitHandleAccessRule rule);
	public void AddAuditRule(EventWaitHandleAuditRule rule);
	public virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
	public Boolean RemoveAccessRule(EventWaitHandleAccessRule rule);
	public void RemoveAccessRuleAll(EventWaitHandleAccessRule rule);
	public void RemoveAccessRuleSpecific(EventWaitHandleAccessRule rule);
	public Boolean RemoveAuditRule(EventWaitHandleAuditRule rule);
	public void RemoveAuditRuleAll(EventWaitHandleAuditRule rule);
	public void RemoveAuditRuleSpecific(EventWaitHandleAuditRule rule);
	public void ResetAccessRule(EventWaitHandleAccessRule rule);
	public void SetAccessRule(EventWaitHandleAccessRule rule);
	public void SetAuditRule(EventWaitHandleAuditRule rule);

	sealed class NativeObjectSecurity
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(Int32 errorCode, String name, SafeHandle handle, Object context, AsyncCallback callback, Object object);
	public virtual Exception EndInvoke(IAsyncResult result);
	public virtual Exception Invoke(Int32 errorCode, String name, SafeHandle handle, Object context);

	public sealed class FileSecurity
	: FileSystemSecurity

	public sealed class FileSystemAccessRule
	: AccessRule
	public FileSystemRights FileSystemRights { get; }

	public sealed class FileSystemAuditRule
	: AuditRule
	public FileSystemRights FileSystemRights { get; }

	public sealed enum FileSystemRights
	: IComparable, IFormattable, IConvertible
	{ ReadData, ListDirectory, WriteData, CreateFiles, AppendData, CreateDirectories, ReadExtendedAttributes, WriteExtendedAttributes, ExecuteFile, Traverse, DeleteSubdirectoriesAndFiles, ReadAttributes, WriteAttributes, Delete, ReadPermissions, ChangePermissions, TakeOwnership, Synchronize, FullControl, Read, ReadAndExecute, Write, Modify }

	public abstract class FileSystemSecurity
	: NativeObjectSecurity
	public virtual Type AccessRightType { get; }
	public virtual Type AccessRuleType { get; }
	public virtual Type AuditRuleType { get; }
	public virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
	public void AddAccessRule(FileSystemAccessRule rule);
	public void AddAuditRule(FileSystemAuditRule rule);
	public virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
	public Boolean RemoveAccessRule(FileSystemAccessRule rule);
	public void RemoveAccessRuleAll(FileSystemAccessRule rule);
	public void RemoveAccessRuleSpecific(FileSystemAccessRule rule);
	public Boolean RemoveAuditRule(FileSystemAuditRule rule);
	public void RemoveAuditRuleAll(FileSystemAuditRule rule);
	public void RemoveAuditRuleSpecific(FileSystemAuditRule rule);
	public void ResetAccessRule(FileSystemAccessRule rule);
	public void SetAccessRule(FileSystemAccessRule rule);
	public void SetAuditRule(FileSystemAuditRule rule);

	public abstract class GenericAce
	public AceFlags AceFlags { get; set; }
	public AceType AceType { get; }
	public AuditFlags AuditFlags { get; }
	public abstract virtual Int32 BinaryLength { get; }
	public InheritanceFlags InheritanceFlags { get; }
	public Boolean IsInherited { get; }
	public PropagationFlags PropagationFlags { get; }
	public GenericAce Copy();
	static public GenericAce CreateFromBinaryForm(Byte binaryForm, Int32 offset);
	public virtual Boolean Equals(Object o);
	public abstract virtual void GetBinaryForm(Byte binaryForm, Int32 offset);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(GenericAce left, GenericAce right);
	static public Boolean op_Inequality(GenericAce left, GenericAce right);

	public abstract class GenericAcl
	: ICollection, IEnumerable
	public abstract virtual Int32 BinaryLength { get; }
	public abstract virtual Int32 Count { get; }
	public virtual Boolean IsSynchronized { get; }
	public abstract virtual GenericAce Item { get; set; }
	public abstract virtual Byte Revision { get; }
	public virtual Object SyncRoot { get; }
	public void CopyTo(GenericAce array, Int32 index);
	public abstract virtual void GetBinaryForm(Byte binaryForm, Int32 offset);
	public AceEnumerator GetEnumerator();

	public abstract class GenericSecurityDescriptor
	public Int32 BinaryLength { get; }
	public abstract virtual ControlFlags ControlFlags { get; }
	public abstract virtual SecurityIdentifier Group { get; set; }
	public abstract virtual SecurityIdentifier Owner { get; set; }
	static public Byte Revision { get; }
	public void GetBinaryForm(Byte binaryForm, Int32 offset);
	public String GetSddlForm(AccessControlSections includeSections);
	static public Boolean IsSddlConversionSupported();

	public sealed enum InheritanceFlags
	: IComparable, IFormattable, IConvertible
	{ None, ContainerInherit, ObjectInherit }

	public abstract class KnownAce
	: GenericAce
	public Int32 AccessMask { get; set; }
	public SecurityIdentifier SecurityIdentifier { get; set; }

	public sealed class MutexAccessRule
	: AccessRule
	public MutexRights MutexRights { get; }

	public sealed class MutexAuditRule
	: AuditRule
	public MutexRights MutexRights { get; }

	public sealed enum MutexRights
	: IComparable, IFormattable, IConvertible
	{ Modify, Delete, ReadPermissions, ChangePermissions, TakeOwnership, Synchronize, FullControl }

	public sealed class MutexSecurity
	: NativeObjectSecurity
	public virtual Type AccessRightType { get; }
	public virtual Type AccessRuleType { get; }
	public virtual Type AuditRuleType { get; }
	public virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
	public void AddAccessRule(MutexAccessRule rule);
	public void AddAuditRule(MutexAuditRule rule);
	public virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
	public Boolean RemoveAccessRule(MutexAccessRule rule);
	public void RemoveAccessRuleAll(MutexAccessRule rule);
	public void RemoveAccessRuleSpecific(MutexAccessRule rule);
	public Boolean RemoveAuditRule(MutexAuditRule rule);
	public void RemoveAuditRuleAll(MutexAuditRule rule);
	public void RemoveAuditRuleSpecific(MutexAuditRule rule);
	public void ResetAccessRule(MutexAccessRule rule);
	public void SetAccessRule(MutexAccessRule rule);
	public void SetAuditRule(MutexAuditRule rule);

	public abstract class NativeObjectSecurity
	: CommonObjectSecurity
	protected virtual void Persist(String name, AccessControlSections includeSections);
	protected void Persist(String name, AccessControlSections includeSections, Object exceptionContext);
	protected virtual void Persist(SafeHandle handle, AccessControlSections includeSections);
	protected void Persist(SafeHandle handle, AccessControlSections includeSections, Object exceptionContext);

	public abstract class ObjectAccessRule
	: AccessRule
	public Guid InheritedObjectType { get; }
	public ObjectAceFlags ObjectFlags { get; }
	public Guid ObjectType { get; }

	public sealed class ObjectAce
	: QualifiedAce
	public virtual Int32 BinaryLength { get; }
	public Guid InheritedObjectAceType { get; set; }
	public ObjectAceFlags ObjectAceFlags { get; set; }
	public Guid ObjectAceType { get; set; }
	public virtual void GetBinaryForm(Byte binaryForm, Int32 offset);
	static public Int32 MaxOpaqueLength(Boolean isCallback);

	public sealed enum ObjectAceFlags
	: IComparable, IFormattable, IConvertible
	{ None, ObjectAceTypePresent, InheritedObjectAceTypePresent }

	public abstract class ObjectAuditRule
	: AuditRule
	public Guid InheritedObjectType { get; }
	public ObjectAceFlags ObjectFlags { get; }
	public Guid ObjectType { get; }

	public abstract class ObjectSecurity
	public abstract virtual Type AccessRightType { get; }
	protected Boolean AccessRulesModified { get; set; }
	public abstract virtual Type AccessRuleType { get; }
	public Boolean AreAccessRulesCanonical { get; }
	public Boolean AreAccessRulesProtected { get; }
	public Boolean AreAuditRulesCanonical { get; }
	public Boolean AreAuditRulesProtected { get; }
	protected Boolean AuditRulesModified { get; set; }
	public abstract virtual Type AuditRuleType { get; }
	protected Boolean GroupModified { get; set; }
	protected Boolean IsContainer { get; }
	protected Boolean IsDS { get; }
	protected Boolean OwnerModified { get; set; }
	public abstract virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
	public abstract virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
	public IdentityReference GetGroup(Type targetType);
	public IdentityReference GetOwner(Type targetType);
	public Byte GetSecurityDescriptorBinaryForm();
	public String GetSecurityDescriptorSddlForm(AccessControlSections includeSections);
	static public Boolean IsSddlConversionSupported();
	protected abstract virtual Boolean ModifyAccess(AccessControlModification modification, AccessRule rule, out Boolean& modified);
	public virtual Boolean ModifyAccessRule(AccessControlModification modification, AccessRule rule, out Boolean& modified);
	protected abstract virtual Boolean ModifyAudit(AccessControlModification modification, AuditRule rule, out Boolean& modified);
	public virtual Boolean ModifyAuditRule(AccessControlModification modification, AuditRule rule, out Boolean& modified);
	protected virtual void Persist(String name, AccessControlSections includeSections);
	protected virtual void Persist(Boolean enableOwnershipPrivilege, String name, AccessControlSections includeSections);
	protected virtual void Persist(SafeHandle handle, AccessControlSections includeSections);
	public virtual void PurgeAccessRules(IdentityReference identity);
	public virtual void PurgeAuditRules(IdentityReference identity);
	protected void ReadLock();
	protected void ReadUnlock();
	public void SetAccessRuleProtection(Boolean isProtected, Boolean preserveInheritance);
	public void SetAuditRuleProtection(Boolean isProtected, Boolean preserveInheritance);
	public void SetGroup(IdentityReference identity);
	public void SetOwner(IdentityReference identity);
	public void SetSecurityDescriptorBinaryForm(Byte binaryForm);
	public void SetSecurityDescriptorBinaryForm(Byte binaryForm, AccessControlSections includeSections);
	public void SetSecurityDescriptorSddlForm(String sddlForm);
	public void SetSecurityDescriptorSddlForm(String sddlForm, AccessControlSections includeSections);
	protected void WriteLock();
	protected void WriteUnlock();

	public abstract class ObjectSecurity`1<T>
	: NativeObjectSecurity where T : ValueType
	public virtual Type AccessRightType { get; }
	public virtual Type AccessRuleType { get; }
	public virtual Type AuditRuleType { get; }
	public virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
	public virtual void AddAccessRule(AccessRule`1<T> rule);
	public virtual void AddAuditRule(AuditRule`1<T> rule);
	public virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
	internal protected void Persist(SafeHandle handle);
	internal protected void Persist(String name);
	public virtual Boolean RemoveAccessRule(AccessRule`1<T> rule);
	public virtual void RemoveAccessRuleAll(AccessRule`1<T> rule);
	public virtual void RemoveAccessRuleSpecific(AccessRule`1<T> rule);
	public virtual Boolean RemoveAuditRule(AuditRule`1<T> rule);
	public virtual void RemoveAuditRuleAll(AuditRule`1<T> rule);
	public virtual void RemoveAuditRuleSpecific(AuditRule`1<T> rule);
	public virtual void ResetAccessRule(AccessRule`1<T> rule);
	public virtual void SetAccessRule(AccessRule`1<T> rule);
	public virtual void SetAuditRule(AuditRule`1<T> rule);

	public sealed class PrivilegeNotHeldException
	: UnauthorizedAccessException, ISerializable, _Exception
	public String PrivilegeName { get; }
	public virtual void GetObjectData(SerializationInfo info, StreamingContext context);

	public sealed enum PropagationFlags
	: IComparable, IFormattable, IConvertible
	{ None, NoPropagateInherit, InheritOnly }

	public abstract class QualifiedAce
	: KnownAce
	public AceQualifier AceQualifier { get; }
	public Boolean IsCallback { get; }
	public Int32 OpaqueLength { get; }
	public Byte GetOpaque();
	public void SetOpaque(Byte opaque);

	public sealed class RawAcl
	: GenericAcl, ICollection, IEnumerable
	public virtual Int32 BinaryLength { get; }
	public virtual Int32 Count { get; }
	public virtual GenericAce Item { get; set; }
	public virtual Byte Revision { get; }
	public virtual void GetBinaryForm(Byte binaryForm, Int32 offset);
	public void InsertAce(Int32 index, GenericAce ace);
	public void RemoveAce(Int32 index);

	public sealed class RawSecurityDescriptor
	: GenericSecurityDescriptor
	public virtual ControlFlags ControlFlags { get; }
	public RawAcl DiscretionaryAcl { get; set; }
	public virtual SecurityIdentifier Group { get; set; }
	public virtual SecurityIdentifier Owner { get; set; }
	public Byte ResourceManagerControl { get; set; }
	public RawAcl SystemAcl { get; set; }
	public void SetFlags(ControlFlags flags);

	public sealed class RegistryAccessRule
	: AccessRule
	public RegistryRights RegistryRights { get; }

	public sealed class RegistryAuditRule
	: AuditRule
	public RegistryRights RegistryRights { get; }

	public sealed enum RegistryRights
	: IComparable, IFormattable, IConvertible
	{ QueryValues, SetValue, CreateSubKey, EnumerateSubKeys, Notify, CreateLink, ExecuteKey, ReadKey, WriteKey, Delete, ReadPermissions, ChangePermissions, TakeOwnership, FullControl }

	public sealed class RegistrySecurity
	: NativeObjectSecurity
	public virtual Type AccessRightType { get; }
	public virtual Type AccessRuleType { get; }
	public virtual Type AuditRuleType { get; }
	public virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
	public void AddAccessRule(RegistryAccessRule rule);
	public void AddAuditRule(RegistryAuditRule rule);
	public virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
	public Boolean RemoveAccessRule(RegistryAccessRule rule);
	public void RemoveAccessRuleAll(RegistryAccessRule rule);
	public void RemoveAccessRuleSpecific(RegistryAccessRule rule);
	public Boolean RemoveAuditRule(RegistryAuditRule rule);
	public void RemoveAuditRuleAll(RegistryAuditRule rule);
	public void RemoveAuditRuleSpecific(RegistryAuditRule rule);
	public void ResetAccessRule(RegistryAccessRule rule);
	public void SetAccessRule(RegistryAccessRule rule);
	public void SetAuditRule(RegistryAuditRule rule);

	public sealed enum ResourceType
	: IComparable, IFormattable, IConvertible
	{ Unknown, FileObject, Service, Printer, RegistryKey, LMShare, KernelObject, WindowObject, DSObject, DSObjectAll, ProviderDefined, WmiGuidObject, RegistryWow6432Key }

	public sealed enum SecurityInfos
	: IComparable, IFormattable, IConvertible
	{ Owner, Group, DiscretionaryAcl, SystemAcl }

	public sealed class SemaphoreAccessRule
	: AccessRule
	public SemaphoreRights SemaphoreRights { get; }

	public sealed class SemaphoreAuditRule
	: AuditRule
	public SemaphoreRights SemaphoreRights { get; }

	public sealed enum SemaphoreRights
	: IComparable, IFormattable, IConvertible
	{ Modify, Delete, ReadPermissions, ChangePermissions, TakeOwnership, Synchronize, FullControl }

	public sealed class SemaphoreSecurity
	: NativeObjectSecurity
	public virtual Type AccessRightType { get; }
	public virtual Type AccessRuleType { get; }
	public virtual Type AuditRuleType { get; }
	public virtual AccessRule AccessRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type);
	public void AddAccessRule(SemaphoreAccessRule rule);
	public void AddAuditRule(SemaphoreAuditRule rule);
	public virtual AuditRule AuditRuleFactory(IdentityReference identityReference, Int32 accessMask, Boolean isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags);
	public Boolean RemoveAccessRule(SemaphoreAccessRule rule);
	public void RemoveAccessRuleAll(SemaphoreAccessRule rule);
	public void RemoveAccessRuleSpecific(SemaphoreAccessRule rule);
	public Boolean RemoveAuditRule(SemaphoreAuditRule rule);
	public void RemoveAuditRuleAll(SemaphoreAuditRule rule);
	public void RemoveAuditRuleSpecific(SemaphoreAuditRule rule);
	public void ResetAccessRule(SemaphoreAccessRule rule);
	public void SetAccessRule(SemaphoreAccessRule rule);
	public void SetAuditRule(SemaphoreAuditRule rule);

	public sealed class SystemAcl
	: CommonAcl, ICollection, IEnumerable
	public void AddAudit(AuditFlags auditFlags, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags);
	public void AddAudit(AuditFlags auditFlags, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType);
	public Boolean RemoveAudit(AuditFlags auditFlags, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags);
	public Boolean RemoveAudit(AuditFlags auditFlags, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType);
	public void RemoveAuditSpecific(AuditFlags auditFlags, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags);
	public void RemoveAuditSpecific(AuditFlags auditFlags, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType);
	public void SetAudit(AuditFlags auditFlags, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags);
	public void SetAudit(AuditFlags auditFlags, SecurityIdentifier sid, Int32 accessMask, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, ObjectAceFlags objectFlags, Guid objectType, Guid inheritedObjectType);