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: 0x02000345 RID: 837
	[Token(Token = "0x2000345")]
	[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: 0x06001E2B RID: 7723 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001E2B")]
		[Address(RVA = "0x1DB8920", Offset = "0x1DB7720", VA = "0x181DB8920")]
		protected WaitHandle()
		{
		}

		// Token: 0x06001E2C RID: 7724 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001E2C")]
		[Address(RVA = "0x1DB7750", Offset = "0x1DB6550", VA = "0x181DB7750")]
		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: 0x17000411 RID: 1041
		// (get) Token: 0x06001E2D RID: 7725 RVA: 0x00013338 File Offset: 0x00011538
		// (set) Token: 0x06001E2E RID: 7726 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x17000411")]
		[Obsolete]
		public virtual IntPtr Handle
		{
			[Token(Token = "0x6001E2D")]
			[Address(RVA = "0x1DB89A0", Offset = "0x1DB77A0", VA = "0x181DB89A0", Slot = "7")]
			get
			{
				return 0;
			}
			[Token(Token = "0x6001E2E")]
			[Address(RVA = "0x1DB8B00", Offset = "0x1DB7900", VA = "0x181DB8B00", 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: 0x17000412 RID: 1042
		// (get) Token: 0x06001E2F RID: 7727 RVA: 0x00002082 File Offset: 0x00000282
		// (set) Token: 0x06001E30 RID: 7728 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x17000412")]
		public SafeWaitHandle SafeWaitHandle
		{
			[Token(Token = "0x6001E2F")]
			[Address(RVA = "0x1DB8A40", Offset = "0x1DB7840", VA = "0x181DB8A40")]
			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
			get
			{
				return null;
			}
			[Token(Token = "0x6001E30")]
			[Address(RVA = "0x1DB8BF0", Offset = "0x1DB79F0", VA = "0x181DB8BF0")]
			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
			set
			{
			}
		}

		// Token: 0x06001E31 RID: 7729 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001E31")]
		[Address(RVA = "0x1DB78E0", Offset = "0x1DB66E0", VA = "0x181DB78E0")]
		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: 0x06001E32 RID: 7730 RVA: 0x00013350 File Offset: 0x00011550
		[Token(Token = "0x6001E32")]
		[Address(RVA = "0x1DB85D0", Offset = "0x1DB73D0", VA = "0x181DB85D0", 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: 0x06001E33 RID: 7731 RVA: 0x00013368 File Offset: 0x00011568
		[Token(Token = "0x6001E33")]
		[Address(RVA = "0x1DB8670", Offset = "0x1DB7470", VA = "0x181DB8670", 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: 0x06001E34 RID: 7732 RVA: 0x00013380 File Offset: 0x00011580
		[Token(Token = "0x6001E34")]
		[Address(RVA = "0x1DB88B0", Offset = "0x1DB76B0", VA = "0x181DB88B0", 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: 0x06001E35 RID: 7733 RVA: 0x00013398 File Offset: 0x00011598
		[Token(Token = "0x6001E35")]
		[Address(RVA = "0x4DBEF0", Offset = "0x4DACF0", VA = "0x1804DBEF0", 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: 0x06001E36 RID: 7734 RVA: 0x000133B0 File Offset: 0x000115B0
		[Token(Token = "0x6001E36")]
		[Address(RVA = "0x499970", Offset = "0x498770", VA = "0x180499970", Slot = "13")]
		public virtual bool WaitOne(TimeSpan timeout)
		{
			return default(bool);
		}

		// Token: 0x06001E37 RID: 7735 RVA: 0x000133C8 File Offset: 0x000115C8
		[Token(Token = "0x6001E37")]
		[Address(RVA = "0x1DB8750", Offset = "0x1DB7550", VA = "0x181DB8750")]
		private bool WaitOne(long timeout, bool exitContext)
		{
			return default(bool);
		}

		// Token: 0x06001E38 RID: 7736 RVA: 0x000133E0 File Offset: 0x000115E0
		[Token(Token = "0x6001E38")]
		[Address(RVA = "0x1DB77D0", Offset = "0x1DB65D0", VA = "0x181DB77D0")]
		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: 0x06001E39 RID: 7737 RVA: 0x000133F8 File Offset: 0x000115F8
		[Token(Token = "0x6001E39")]
		[Address(RVA = "0x1DB79D0", Offset = "0x1DB67D0", VA = "0x181DB79D0")]
		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: 0x06001E3A RID: 7738 RVA: 0x00013410 File Offset: 0x00011610
		[Token(Token = "0x6001E3A")]
		[Address(RVA = "0x1DB7CE0", Offset = "0x1DB6AE0", VA = "0x181DB7CE0")]
		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: 0x06001E3B RID: 7739 RVA: 0x00013428 File Offset: 0x00011628
		[Token(Token = "0x6001E3B")]
		[Address(RVA = "0x1DB7D50", Offset = "0x1DB6B50", VA = "0x181DB7D50")]
		[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: 0x06001E3C RID: 7740 RVA: 0x00013440 File Offset: 0x00011640
		[Token(Token = "0x6001E3C")]
		[Address(RVA = "0x1DB8110", Offset = "0x1DB6F10", VA = "0x181DB8110")]
		[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: 0x06001E3D RID: 7741 RVA: 0x00013458 File Offset: 0x00011658
		[Token(Token = "0x6001E3D")]
		[Address(RVA = "0x1DB80B0", Offset = "0x1DB6EB0", VA = "0x181DB80B0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		public static int WaitAny(WaitHandle[] waitHandles)
		{
			return 0;
		}

		// Token: 0x06001E3E RID: 7742 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001E3E")]
		[Address(RVA = "0x1DB7920", Offset = "0x1DB6720", VA = "0x181DB7920")]
		private static void ThrowAbandonedMutexException()
		{
		}

		// Token: 0x06001E3F RID: 7743 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001E3F")]
		[Address(RVA = "0x1DB7970", Offset = "0x1DB6770", VA = "0x181DB7970")]
		private static void ThrowAbandonedMutexException(int location, WaitHandle handle)
		{
		}

		/// <summary>Releases all resources held by the current <see cref="T:System.Threading.WaitHandle" />.</summary>
		// Token: 0x06001E40 RID: 7744 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001E40")]
		[Address(RVA = "0x1DB7620", Offset = "0x1DB6420", VA = "0x181DB7620", 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: 0x06001E41 RID: 7745 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001E41")]
		[Address(RVA = "0x1DB7690", Offset = "0x1DB6490", VA = "0x181DB7690", 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: 0x06001E42 RID: 7746 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001E42")]
		[Address(RVA = "0x1DB76E0", Offset = "0x1DB64E0", VA = "0x181DB76E0", Slot = "6")]
		public void Dispose()
		{
		}

		// Token: 0x06001E43 RID: 7747 RVA: 0x00013470 File Offset: 0x00011670
		[Token(Token = "0x6001E43")]
		[Address(RVA = "0x1DB8210", Offset = "0x1DB7010", VA = "0x181DB8210")]
		private static int WaitMultiple(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext, bool WaitAll)
		{
			return 0;
		}

		// Token: 0x06001E44 RID: 7748 RVA: 0x00013488 File Offset: 0x00011688
		[Token(Token = "0x6001E44")]
		[Address(RVA = "0x1DB84C0", Offset = "0x1DB72C0", VA = "0x181DB84C0")]
		private static int WaitOneNative(SafeHandle waitableSafeHandle, uint millisecondsTimeout, bool hasThreadAffinity, bool exitContext)
		{
			return 0;
		}

		// Token: 0x06001E45 RID: 7749 RVA: 0x000134A0 File Offset: 0x000116A0
		[Token(Token = "0x6001E45")]
		[Address(RVA = "0x1DB88D0", Offset = "0x1DB76D0", VA = "0x181DB88D0")]
		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: 0x04001117 RID: 4375
		[Token(Token = "0x4001117")]
		public const int WaitTimeout = 258;

		// Token: 0x04001118 RID: 4376
		[Token(Token = "0x4001118")]
		private const int MAX_WAITHANDLES = 64;

		// Token: 0x04001119 RID: 4377
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
		[Token(Token = "0x4001119")]
		private IntPtr waitHandle;

		// Token: 0x0400111A RID: 4378
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
		[Token(Token = "0x400111A")]
		internal SafeWaitHandle safeWaitHandle;

		// Token: 0x0400111B RID: 4379
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
		[Token(Token = "0x400111B")]
		internal bool hasThreadAffinity;

		// Token: 0x0400111C RID: 4380
		[Token(Token = "0x400111C")]
		private const int WAIT_OBJECT_0 = 0;

		// Token: 0x0400111D RID: 4381
		[Token(Token = "0x400111D")]
		private const int WAIT_ABANDONED = 128;

		// Token: 0x0400111E RID: 4382
		[Token(Token = "0x400111E")]
		private const int WAIT_FAILED = 2147483647;

		// Token: 0x0400111F RID: 4383
		[Token(Token = "0x400111F")]
		private const int ERROR_TOO_MANY_POSTS = 298;

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

		// Token: 0x04001121 RID: 4385
		[Token(Token = "0x4001121")]
		internal const int MaxWaitHandles = 64;
	}
}