using System;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using Cpp2IlInjected;
using Microsoft.Win32.SafeHandles;

namespace System.Threading
{
	/// <summary>Encapsulates operating system-specific objects that wait for exclusive access to shared resources.</summary>
	// Token: 0x0200035F RID: 863
	[Token(Token = "0x200035F")]
	[ComVisible(true)]
	[StructLayout(0)]
	public abstract class WaitHandle : MarshalByRefObject, IDisposable
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Threading.WaitHandle" /> class.</summary>
		// Token: 0x0600202D RID: 8237 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600202D")]
		[Address(RVA = "0xF86700", Offset = "0xF85700", VA = "0x180F86700")]
		protected WaitHandle()
		{
		}

		// Token: 0x0600202E RID: 8238 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600202E")]
		[Address(RVA = "0xF85530", Offset = "0xF84530", VA = "0x180F85530")]
		private void Init()
		{
		}

		/// <summary>Gets or sets the native operating system handle.</summary>
		/// <returns>An <see langword="IntPtr" /> representing the native operating system handle. The default is the value of the <see cref="F:System.Threading.WaitHandle.InvalidHandle" /> field.</returns>
		// Token: 0x17000487 RID: 1159
		// (get) Token: 0x0600202F RID: 8239 RVA: 0x000156D8 File Offset: 0x000138D8
		// (set) Token: 0x06002030 RID: 8240 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x17000487")]
		[Obsolete]
		public virtual IntPtr Handle
		{
			[Token(Token = "0x600202F")]
			[Address(RVA = "0xF86780", Offset = "0xF85780", VA = "0x180F86780", Slot = "7")]
			get
			{
				return 0;
			}
			[Token(Token = "0x6002030")]
			[Address(RVA = "0xF868E0", Offset = "0xF858E0", VA = "0x180F868E0", Slot = "8")]
			set
			{
			}
		}

		/// <summary>Gets or sets the native operating system handle.</summary>
		/// <returns>A <see cref="T:Microsoft.Win32.SafeHandles.SafeWaitHandle" /> representing the native operating system handle.</returns>
		// Token: 0x17000488 RID: 1160
		// (get) Token: 0x06002031 RID: 8241 RVA: 0x00002082 File Offset: 0x00000282
		// (set) Token: 0x06002032 RID: 8242 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x17000488")]
		public SafeWaitHandle SafeWaitHandle
		{
			[Token(Token = "0x6002031")]
			[Address(RVA = "0xF86820", Offset = "0xF85820", VA = "0x180F86820")]
			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
			get
			{
				return null;
			}
			[Token(Token = "0x6002032")]
			[Address(RVA = "0xF869D0", Offset = "0xF859D0", VA = "0x180F869D0")]
			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
			set
			{
			}
		}

		// Token: 0x06002033 RID: 8243 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6002033")]
		[Address(RVA = "0xF856C0", Offset = "0xF846C0", VA = "0x180F856C0")]
		internal void SetHandleInternal(SafeWaitHandle handle)
		{
		}

		/// <summary>Blocks the current thread until the current <see cref="T:System.Threading.WaitHandle" /> receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.</summary>
		/// <param name="millisecondsTimeout">The number of milliseconds to wait, or <see cref="F:System.Threading.Timeout.Infinite" /> (-1) to wait indefinitely.</param>
		/// <param name="exitContext">
		///   <see langword="true" /> to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, <see langword="false" />.</param>
		/// <returns>
		///   <see langword="true" /> if the current instance receives a signal; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ObjectDisposedException">The current instance has already been disposed.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="millisecondsTimeout" /> is a negative number other than -1, which represents an infinite time-out.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.InvalidOperationException">The current instance is a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x06002034 RID: 8244 RVA: 0x000156F0 File Offset: 0x000138F0
		[Token(Token = "0x6002034")]
		[Address(RVA = "0xF863B0", Offset = "0xF853B0", VA = "0x180F863B0", Slot = "9")]
		public virtual bool WaitOne(int millisecondsTimeout, bool exitContext)
		{
			return default(bool);
		}

		/// <summary>Blocks the current thread until the current instance receives a signal, using a <see cref="T:System.TimeSpan" /> to specify the time interval and specifying whether to exit the synchronization domain before the wait.</summary>
		/// <param name="timeout">A <see cref="T:System.TimeSpan" /> that represents the number of milliseconds to wait, or a <see cref="T:System.TimeSpan" /> that represents -1 milliseconds to wait indefinitely.</param>
		/// <param name="exitContext">
		///   <see langword="true" /> to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, <see langword="false" />.</param>
		/// <returns>
		///   <see langword="true" /> if the current instance receives a signal; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ObjectDisposedException">The current instance has already been disposed.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="timeout" /> is a negative number other than -1 milliseconds, which represents an infinite time-out.  
		/// -or-  
		/// <paramref name="timeout" /> is greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.InvalidOperationException">The current instance is a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x06002035 RID: 8245 RVA: 0x00015708 File Offset: 0x00013908
		[Token(Token = "0x6002035")]
		[Address(RVA = "0xF86450", Offset = "0xF85450", VA = "0x180F86450", Slot = "10")]
		public virtual bool WaitOne(TimeSpan timeout, bool exitContext)
		{
			return default(bool);
		}

		/// <summary>Blocks the current thread until the current <see cref="T:System.Threading.WaitHandle" /> receives a signal.</summary>
		/// <returns>
		///   <see langword="true" /> if the current instance receives a signal. If the current instance is never signaled, <see cref="M:System.Threading.WaitHandle.WaitOne(System.Int32,System.Boolean)" /> never returns.</returns>
		/// <exception cref="T:System.ObjectDisposedException">The current instance has already been disposed.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.InvalidOperationException">The current instance is a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x06002036 RID: 8246 RVA: 0x00015720 File Offset: 0x00013920
		[Token(Token = "0x6002036")]
		[Address(RVA = "0xF86690", Offset = "0xF85690", VA = "0x180F86690", Slot = "11")]
		public virtual bool WaitOne()
		{
			return default(bool);
		}

		/// <summary>Blocks the current thread until the current <see cref="T:System.Threading.WaitHandle" /> receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.</summary>
		/// <param name="millisecondsTimeout">The number of milliseconds to wait, or <see cref="F:System.Threading.Timeout.Infinite" /> (-1) to wait indefinitely.</param>
		/// <returns>
		///   <see langword="true" /> if the current instance receives a signal; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ObjectDisposedException">The current instance has already been disposed.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="millisecondsTimeout" /> is a negative number other than -1, which represents an infinite time-out.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.InvalidOperationException">The current instance is a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x06002037 RID: 8247 RVA: 0x00015738 File Offset: 0x00013938
		[Token(Token = "0x6002037")]
		[Address(RVA = "0x880D60", Offset = "0x87FD60", VA = "0x180880D60", Slot = "12")]
		public virtual bool WaitOne(int millisecondsTimeout)
		{
			return default(bool);
		}

		/// <summary>Blocks the current thread until the current instance receives a signal, using a <see cref="T:System.TimeSpan" /> to specify the time interval.</summary>
		/// <param name="timeout">A <see cref="T:System.TimeSpan" /> that represents the number of milliseconds to wait, or a <see cref="T:System.TimeSpan" /> that represents -1 milliseconds to wait indefinitely.</param>
		/// <returns>
		///   <see langword="true" /> if the current instance receives a signal; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ObjectDisposedException">The current instance has already been disposed.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="timeout" /> is a negative number other than -1 milliseconds, which represents an infinite time-out.  
		/// -or-  
		/// <paramref name="timeout" /> is greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.InvalidOperationException">The current instance is a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x06002038 RID: 8248 RVA: 0x00015750 File Offset: 0x00013950
		[Token(Token = "0x6002038")]
		[Address(RVA = "0xB96630", Offset = "0xB95630", VA = "0x180B96630", Slot = "13")]
		public virtual bool WaitOne(TimeSpan timeout)
		{
			return default(bool);
		}

		// Token: 0x06002039 RID: 8249 RVA: 0x00015768 File Offset: 0x00013968
		[Token(Token = "0x6002039")]
		[Address(RVA = "0xF86530", Offset = "0xF85530", VA = "0x180F86530")]
		private bool WaitOne(long timeout, bool exitContext)
		{
			return default(bool);
		}

		// Token: 0x0600203A RID: 8250 RVA: 0x00015780 File Offset: 0x00013980
		[Token(Token = "0x600203A")]
		[Address(RVA = "0xF855B0", Offset = "0xF845B0", VA = "0x180F855B0")]
		internal static bool InternalWaitOne(SafeHandle waitableSafeHandle, long millisecondsTimeout, bool hasThreadAffinity, bool exitContext)
		{
			return default(bool);
		}

		/// <summary>Waits for all the elements in the specified array to receive a signal, using an <see cref="T:System.Int32" /> value to specify the time interval and specifying whether to exit the synchronization domain before the wait.</summary>
		/// <param name="waitHandles">A <see langword="WaitHandle" /> array containing the objects for which the current instance will wait. This array cannot contain multiple references to the same object (duplicates).</param>
		/// <param name="millisecondsTimeout">The number of milliseconds to wait, or <see cref="F:System.Threading.Timeout.Infinite" /> (-1) to wait indefinitely.</param>
		/// <param name="exitContext">
		///   <see langword="true" /> to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, <see langword="false" />.</param>
		/// <returns>
		///   <see langword="true" /> when every element in <paramref name="waitHandles" /> has received a signal; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="waitHandles" /> parameter is <see langword="null" />.  
		///  -or-  
		///  One or more of the objects in the <paramref name="waitHandles" /> array is <see langword="null" />.  
		///  -or-  
		///  <paramref name="waitHandles" /> is an array with no elements and the .NET Framework version is 2.0 or later.</exception>
		/// <exception cref="T:System.DuplicateWaitObjectException">The <paramref name="waitHandles" /> array contains elements that are duplicates.</exception>
		/// <exception cref="T:System.NotSupportedException">The number of objects in <paramref name="waitHandles" /> is greater than the system permits.  
		///  -or-  
		///  The <see cref="T:System.STAThreadAttribute" /> attribute is applied to the thread procedure for the current thread, and <paramref name="waitHandles" /> contains more than one element.</exception>
		/// <exception cref="T:System.ApplicationException">
		///   <paramref name="waitHandles" /> is an array with no elements and the .NET Framework version is 1.0 or 1.1.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="millisecondsTimeout" /> is a negative number other than -1, which represents an infinite time-out.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.InvalidOperationException">The <paramref name="waitHandles" /> array contains a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x0600203B RID: 8251 RVA: 0x00015798 File Offset: 0x00013998
		[Token(Token = "0x600203B")]
		[Address(RVA = "0xF857B0", Offset = "0xF847B0", VA = "0x180F857B0")]
		public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
		{
			return default(bool);
		}

		/// <summary>Waits for all the elements in the specified array to receive a signal, using an <see cref="T:System.Int32" /> value to specify the time interval.</summary>
		/// <param name="waitHandles">A <see langword="WaitHandle" /> array containing the objects for which the current instance will wait. This array cannot contain multiple references to the same object (duplicates).</param>
		/// <param name="millisecondsTimeout">The number of milliseconds to wait, or <see cref="F:System.Threading.Timeout.Infinite" /> (-1) to wait indefinitely.</param>
		/// <returns>
		///   <see langword="true" /> when every element in <paramref name="waitHandles" /> has received a signal; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="waitHandles" /> parameter is <see langword="null" />.  
		///  -or-  
		///  One or more of the objects in the <paramref name="waitHandles" /> array is <see langword="null" />.  
		///  -or-  
		///  <paramref name="waitHandles" /> is an array with no elements.</exception>
		/// <exception cref="T:System.DuplicateWaitObjectException">In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, <see cref="T:System.ArgumentException" />, instead.  
		///
		///
		///
		///
		///  The <paramref name="waitHandles" /> array contains elements that are duplicates.</exception>
		/// <exception cref="T:System.NotSupportedException">The number of objects in <paramref name="waitHandles" /> is greater than the system permits.  
		///  -or-  
		///  The <see cref="T:System.STAThreadAttribute" /> attribute is applied to the thread procedure for the current thread, and <paramref name="waitHandles" /> contains more than one element.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="millisecondsTimeout" /> is a negative number other than -1, which represents an infinite time-out.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.InvalidOperationException">The <paramref name="waitHandles" /> array contains a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x0600203C RID: 8252 RVA: 0x000157B0 File Offset: 0x000139B0
		[Token(Token = "0x600203C")]
		[Address(RVA = "0xF85AC0", Offset = "0xF84AC0", VA = "0x180F85AC0")]
		public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout)
		{
			return default(bool);
		}

		/// <summary>Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval, and specifying whether to exit the synchronization domain before the wait.</summary>
		/// <param name="waitHandles">A <see langword="WaitHandle" /> array containing the objects for which the current instance will wait.</param>
		/// <param name="millisecondsTimeout">The number of milliseconds to wait, or <see cref="F:System.Threading.Timeout.Infinite" /> (-1) to wait indefinitely.</param>
		/// <param name="exitContext">
		///   <see langword="true" /> to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, <see langword="false" />.</param>
		/// <returns>The array index of the object that satisfied the wait, or <see cref="F:System.Threading.WaitHandle.WaitTimeout" /> if no object satisfied the wait and a time interval equivalent to <paramref name="millisecondsTimeout" /> has passed.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="waitHandles" /> parameter is <see langword="null" />.  
		///  -or-  
		///  One or more of the objects in the <paramref name="waitHandles" /> array is <see langword="null" />.</exception>
		/// <exception cref="T:System.NotSupportedException">The number of objects in <paramref name="waitHandles" /> is greater than the system permits.</exception>
		/// <exception cref="T:System.ApplicationException">
		///   <paramref name="waitHandles" /> is an array with no elements, and the .NET Framework version is 1.0 or 1.1.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="millisecondsTimeout" /> is a negative number other than -1, which represents an infinite time-out.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="waitHandles" /> is an array with no elements, and the .NET Framework version is 2.0 or later.</exception>
		/// <exception cref="T:System.InvalidOperationException">The <paramref name="waitHandles" /> array contains a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x0600203D RID: 8253 RVA: 0x000157C8 File Offset: 0x000139C8
		[Token(Token = "0x600203D")]
		[Address(RVA = "0xF85B30", Offset = "0xF84B30", VA = "0x180F85B30")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
		{
			return 0;
		}

		/// <summary>Waits for any of the elements in the specified array to receive a signal, using a <see cref="T:System.TimeSpan" /> to specify the time interval and specifying whether to exit the synchronization domain before the wait.</summary>
		/// <param name="waitHandles">A <see langword="WaitHandle" /> array containing the objects for which the current instance will wait.</param>
		/// <param name="timeout">A <see cref="T:System.TimeSpan" /> that represents the number of milliseconds to wait, or a <see cref="T:System.TimeSpan" /> that represents -1 milliseconds to wait indefinitely.</param>
		/// <param name="exitContext">
		///   <see langword="true" /> to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it afterward; otherwise, <see langword="false" />.</param>
		/// <returns>The array index of the object that satisfied the wait, or <see cref="F:System.Threading.WaitHandle.WaitTimeout" /> if no object satisfied the wait and a time interval equivalent to <paramref name="timeout" /> has passed.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="waitHandles" /> parameter is <see langword="null" />.  
		///  -or-  
		///  One or more of the objects in the <paramref name="waitHandles" /> array is <see langword="null" />.</exception>
		/// <exception cref="T:System.NotSupportedException">The number of objects in <paramref name="waitHandles" /> is greater than the system permits.</exception>
		/// <exception cref="T:System.ApplicationException">
		///   <paramref name="waitHandles" /> is an array with no elements, and the .NET Framework version is 1.0 or 1.1.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="timeout" /> is a negative number other than -1 milliseconds, which represents an infinite time-out.  
		/// -or-  
		/// <paramref name="timeout" /> is greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="waitHandles" /> is an array with no elements, and the .NET Framework version is 2.0 or later.</exception>
		/// <exception cref="T:System.InvalidOperationException">The <paramref name="waitHandles" /> array contains a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x0600203E RID: 8254 RVA: 0x000157E0 File Offset: 0x000139E0
		[Token(Token = "0x600203E")]
		[Address(RVA = "0xF85EF0", Offset = "0xF84EF0", VA = "0x180F85EF0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext)
		{
			return 0;
		}

		/// <summary>Waits for any of the elements in the specified array to receive a signal.</summary>
		/// <param name="waitHandles">A <see langword="WaitHandle" /> array containing the objects for which the current instance will wait.</param>
		/// <returns>The array index of the object that satisfied the wait.</returns>
		/// <exception cref="T:System.ArgumentNullException">The <paramref name="waitHandles" /> parameter is <see langword="null" />.  
		///  -or-  
		///  One or more of the objects in the <paramref name="waitHandles" /> array is <see langword="null" />.</exception>
		/// <exception cref="T:System.NotSupportedException">The number of objects in <paramref name="waitHandles" /> is greater than the system permits.</exception>
		/// <exception cref="T:System.ApplicationException">
		///   <paramref name="waitHandles" /> is an array with no elements, and the .NET Framework version is 1.0 or 1.1.</exception>
		/// <exception cref="T:System.Threading.AbandonedMutexException">The wait completed because a thread exited without releasing a mutex. This exception is not thrown on Windows 98 or Windows Millennium Edition.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="waitHandles" /> is an array with no elements, and the .NET Framework version is 2.0 or later.</exception>
		/// <exception cref="T:System.InvalidOperationException">The <paramref name="waitHandles" /> array contains a transparent proxy for a <see cref="T:System.Threading.WaitHandle" /> in another application domain.</exception>
		// Token: 0x0600203F RID: 8255 RVA: 0x000157F8 File Offset: 0x000139F8
		[Token(Token = "0x600203F")]
		[Address(RVA = "0xF85E90", Offset = "0xF84E90", VA = "0x180F85E90")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		public static int WaitAny(WaitHandle[] waitHandles)
		{
			return 0;
		}

		// Token: 0x06002040 RID: 8256 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6002040")]
		[Address(RVA = "0xF85700", Offset = "0xF84700", VA = "0x180F85700")]
		private static void ThrowAbandonedMutexException()
		{
		}

		// Token: 0x06002041 RID: 8257 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6002041")]
		[Address(RVA = "0xF85750", Offset = "0xF84750", VA = "0x180F85750")]
		private static void ThrowAbandonedMutexException(int location, WaitHandle handle)
		{
		}

		/// <summary>Releases all resources held by the current <see cref="T:System.Threading.WaitHandle" />.</summary>
		// Token: 0x06002042 RID: 8258 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6002042")]
		[Address(RVA = "0xF85400", Offset = "0xF84400", VA = "0x180F85400", Slot = "14")]
		public virtual void Close()
		{
		}

		/// <summary>When overridden in a derived class, releases the unmanaged resources used by the <see cref="T:System.Threading.WaitHandle" />, and optionally releases the managed resources.</summary>
		/// <param name="explicitDisposing">
		///   <see langword="true" /> to release both managed and unmanaged resources; <see langword="false" /> to release only unmanaged resources.</param>
		// Token: 0x06002043 RID: 8259 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6002043")]
		[Address(RVA = "0xF85470", Offset = "0xF84470", VA = "0x180F85470", Slot = "15")]
		protected virtual void Dispose(bool explicitDisposing)
		{
		}

		/// <summary>Releases all resources used by the current instance of the <see cref="T:System.Threading.WaitHandle" /> class.</summary>
		// Token: 0x06002044 RID: 8260 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6002044")]
		[Address(RVA = "0xF854C0", Offset = "0xF844C0", VA = "0x180F854C0", Slot = "6")]
		public void Dispose()
		{
		}

		// Token: 0x06002045 RID: 8261 RVA: 0x00015810 File Offset: 0x00013A10
		[Token(Token = "0x6002045")]
		[Address(RVA = "0xF85FF0", Offset = "0xF84FF0", VA = "0x180F85FF0")]
		private static int WaitMultiple(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext, bool WaitAll)
		{
			return 0;
		}

		// Token: 0x06002046 RID: 8262 RVA: 0x00015828 File Offset: 0x00013A28
		[Token(Token = "0x6002046")]
		[Address(RVA = "0xF862A0", Offset = "0xF852A0", VA = "0x180F862A0")]
		private static int WaitOneNative(SafeHandle waitableSafeHandle, uint millisecondsTimeout, bool hasThreadAffinity, bool exitContext)
		{
			return 0;
		}

		// Token: 0x06002047 RID: 8263 RVA: 0x00015840 File Offset: 0x00013A40
		[Token(Token = "0x6002047")]
		[Address(RVA = "0xF866B0", Offset = "0xF856B0", VA = "0x180F866B0")]
		private unsafe static int Wait_internal(IntPtr* handles, int numHandles, bool waitAll, int ms)
		{
			return 0;
		}

		/// <summary>Indicates that a <see cref="M:System.Threading.WaitHandle.WaitAny(System.Threading.WaitHandle[],System.Int32,System.Boolean)" /> operation timed out before any of the wait handles were signaled. This field is constant.</summary>
		// Token: 0x040011D2 RID: 4562
		[Token(Token = "0x40011D2")]
		public const int WaitTimeout = 258;

		// Token: 0x040011D3 RID: 4563
		[Token(Token = "0x40011D3")]
		private const int MAX_WAITHANDLES = 64;

		// Token: 0x040011D4 RID: 4564
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
		[Token(Token = "0x40011D4")]
		private IntPtr waitHandle;

		// Token: 0x040011D5 RID: 4565
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
		[Token(Token = "0x40011D5")]
		internal SafeWaitHandle safeWaitHandle;

		// Token: 0x040011D6 RID: 4566
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
		[Token(Token = "0x40011D6")]
		internal bool hasThreadAffinity;

		// Token: 0x040011D7 RID: 4567
		[Token(Token = "0x40011D7")]
		private const int WAIT_OBJECT_0 = 0;

		// Token: 0x040011D8 RID: 4568
		[Token(Token = "0x40011D8")]
		private const int WAIT_ABANDONED = 128;

		// Token: 0x040011D9 RID: 4569
		[Token(Token = "0x40011D9")]
		private const int WAIT_FAILED = 2147483647;

		// Token: 0x040011DA RID: 4570
		[Token(Token = "0x40011DA")]
		private const int ERROR_TOO_MANY_POSTS = 298;

		/// <summary>Represents an invalid native operating system handle. This field is read-only.</summary>
		// Token: 0x040011DB RID: 4571
		[Token(Token = "0x40011DB")]
		protected static readonly IntPtr InvalidHandle;

		// Token: 0x040011DC RID: 4572
		[Token(Token = "0x40011DC")]
		internal const int MaxWaitHandles = 64;
	}
}