using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;

[assembly: BestFitMapping(false)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("System.Transactions.dll")]
[assembly: AssemblyDescription("System.Transactions.dll")]
[assembly: AssemblyDefaultAlias("System.Transactions.dll")]
[assembly: AssemblyCompany("Mono development team")]
[assembly: AssemblyProduct("Mono Common Language Infrastructure")]
[assembly: AssemblyCopyright("(c) Various Mono authors")]
[assembly: SatelliteContractVersion("4.0.0.0")]
[assembly: AssemblyInformationalVersion("4.0.30319.17020")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: ComVisible(false)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: CLSCompliant(true)]
[assembly: AssemblyDelaySign(true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyFileVersion("4.0.30319.17020")]
[assembly: AssemblyVersion("4.0.0.0")]
internal static class Consts
{
	public const string MonoVersion = "5.11.0.0";

	public const string MonoCompany = "Mono development team";

	public const string MonoProduct = "Mono Common Language Infrastructure";

	public const string MonoCopyright = "(c) Various Mono authors";

	public const int MonoCorlibVersion = 1051100001;

	public const string FxVersion = "4.0.0.0";

	public const string FxFileVersion = "4.0.30319.17020";

	public const string EnvironmentVersion = "4.0.30319.17020";

	public const string VsVersion = "0.0.0.0";

	public const string VsFileVersion = "11.0.0.0";

	private const string PublicKeyToken = "b77a5c561934e089";

	public const string AssemblyI18N = "I18N, Version=4.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756";

	public const string AssemblyMicrosoft_JScript = "Microsoft.JScript, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblyMicrosoft_VisualStudio = "Microsoft.VisualStudio, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblyMicrosoft_VisualStudio_Web = "Microsoft.VisualStudio.Web, Version=0.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblyMicrosoft_VSDesigner = "Microsoft.VSDesigner, Version=0.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblyMono_Http = "Mono.Http, Version=4.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756";

	public const string AssemblyMono_Posix = "Mono.Posix, Version=4.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756";

	public const string AssemblyMono_Security = "Mono.Security, Version=4.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756";

	public const string AssemblyMono_Messaging_RabbitMQ = "Mono.Messaging.RabbitMQ, Version=4.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756";

	public const string AssemblyCorlib = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";

	public const string AssemblySystem = "System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";

	public const string AssemblySystem_Data = "System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";

	public const string AssemblySystem_Design = "System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblySystem_DirectoryServices = "System.DirectoryServices, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblySystem_Drawing = "System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblySystem_Drawing_Design = "System.Drawing.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblySystem_Messaging = "System.Messaging, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblySystem_Security = "System.Security, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblySystem_ServiceProcess = "System.ServiceProcess, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblySystem_Web = "System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";

	public const string AssemblySystem_Windows_Forms = "System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";

	public const string AssemblySystem_2_0 = "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";

	public const string AssemblySystemCore_3_5 = "System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";

	public const string AssemblySystem_Core = "System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";

	public const string WindowsBase_3_0 = "WindowsBase, Version=3.0.0.0, PublicKeyToken=31bf3856ad364e35";

	public const string AssemblyWindowsBase = "WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";

	public const string AssemblyPresentationCore_3_5 = "PresentationCore, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";

	public const string AssemblyPresentationCore_4_0 = "PresentationCore, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";

	public const string AssemblyPresentationFramework_3_5 = "PresentationFramework, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";

	public const string AssemblySystemServiceModel_3_0 = "System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
}
internal sealed class Locale
{
	[MethodImpl(MethodImplOptions.NoInlining)]
	private Locale()
	{
		throw null;
	}

	[MethodImpl(MethodImplOptions.NoInlining)]
	public static string GetText(string msg)
	{
		throw null;
	}

	[MethodImpl(MethodImplOptions.NoInlining)]
	public static string GetText(string fmt, params object[] args)
	{
		throw null;
	}
}
namespace System
{
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
	internal class MonoTODOAttribute : Attribute
	{
		private string comment;

		public string Comment
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public MonoTODOAttribute()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public MonoTODOAttribute(string comment)
		{
			throw null;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
	internal class MonoDocumentationNoteAttribute : MonoTODOAttribute
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public MonoDocumentationNoteAttribute(string comment)
		{
			throw null;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
	internal class MonoExtensionAttribute : MonoTODOAttribute
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public MonoExtensionAttribute(string comment)
		{
			throw null;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
	internal class MonoInternalNoteAttribute : MonoTODOAttribute
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public MonoInternalNoteAttribute(string comment)
		{
			throw null;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
	internal class MonoLimitationAttribute : MonoTODOAttribute
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public MonoLimitationAttribute(string comment)
		{
			throw null;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
	internal class MonoNotSupportedAttribute : MonoTODOAttribute
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public MonoNotSupportedAttribute(string comment)
		{
			throw null;
		}
	}
}
namespace System.Transactions
{
	[Serializable]
	public sealed class CommittableTransaction : Transaction, ISerializable, IDisposable, IAsyncResult
	{
		private TransactionOptions options;

		private AsyncCallback callback;

		private object user_defined_state;

		private IAsyncResult asyncResult;

		object IAsyncResult.AsyncState
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		WaitHandle IAsyncResult.AsyncWaitHandle
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		bool IAsyncResult.CompletedSynchronously
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		bool IAsyncResult.IsCompleted
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public CommittableTransaction()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public CommittableTransaction(TimeSpan timeout)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public CommittableTransaction(TransactionOptions options)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public IAsyncResult BeginCommit(AsyncCallback asyncCallback, object asyncState)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void EndCommit(IAsyncResult asyncResult)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void CommitCallback(IAsyncResult ar)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Commit()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("Not implemented")]
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw null;
		}
	}
	public delegate Transaction HostCurrentTransactionCallback();
	public delegate void TransactionCompletedEventHandler(object sender, TransactionEventArgs e);
	public delegate void TransactionStartedEventHandler(object sender, TransactionEventArgs e);
	public enum DependentCloneOption
	{
		BlockCommitUntilComplete,
		RollbackIfNotComplete
	}
	[Serializable]
	[MonoTODO("Not supported yet")]
	public sealed class DependentTransaction : Transaction, ISerializable
	{
		private bool completed;

		internal bool Completed
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal DependentTransaction(Transaction parent, DependentCloneOption option)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public void Complete()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal DependentTransaction()
		{
			throw null;
		}
	}
	public class Enlistment
	{
		internal bool done;

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal Enlistment()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Done()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal virtual void InternalOnDone()
		{
			throw null;
		}
	}
	[Flags]
	public enum EnlistmentOptions
	{
		None = 0,
		EnlistDuringPrepareRequired = 1
	}
	public enum EnterpriseServicesInteropOption
	{
		None,
		Automatic,
		Full
	}
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IDtcTransaction
	{
		void Abort(IntPtr reason, int retaining, int async);

		void Commit(int retaining, int commitType, int reserved);

		void GetTransactionInfo(IntPtr transactionInformation);
	}
	public interface IEnlistmentNotification
	{
		void Commit(Enlistment enlistment);

		void InDoubt(Enlistment enlistment);

		void Prepare(PreparingEnlistment preparingEnlistment);

		void Rollback(Enlistment enlistment);
	}
	public interface IPromotableSinglePhaseNotification : ITransactionPromoter
	{
		void Initialize();

		void Rollback(SinglePhaseEnlistment singlePhaseEnlistment);

		void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment);
	}
	public interface ISimpleTransactionSuperior : ITransactionPromoter
	{
		void Rollback();
	}
	public interface ISinglePhaseNotification : IEnlistmentNotification
	{
		void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment);
	}
	public interface ITransactionPromoter
	{
		byte[] Promote();
	}
	public enum IsolationLevel
	{
		Serializable,
		RepeatableRead,
		ReadCommitted,
		ReadUncommitted,
		Snapshot,
		Chaos,
		Unspecified
	}
	public class PreparingEnlistment : Enlistment
	{
		private bool prepared;

		private Transaction tx;

		private IEnlistmentNotification enlisted;

		private WaitHandle waitHandle;

		private Exception ex;

		internal bool IsPrepared
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		internal WaitHandle WaitHandle
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		internal IEnlistmentNotification EnlistmentNotification
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		internal Exception Exception
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal PreparingEnlistment(Transaction tx, IEnlistmentNotification enlisted)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void ForceRollback()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal override void InternalOnDone()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public void ForceRollback(Exception e)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public void Prepared()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public byte[] RecoveryInformation()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal PreparingEnlistment()
		{
			throw null;
		}
	}
	public class SinglePhaseEnlistment : Enlistment
	{
		private Transaction tx;

		private object abortingEnlisted;

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal SinglePhaseEnlistment()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal SinglePhaseEnlistment(Transaction tx, object abortingEnlisted)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Aborted()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Aborted(Exception e)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public void Committed()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("Not implemented")]
		public void InDoubt()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("Not implemented")]
		public void InDoubt(Exception e)
		{
			throw null;
		}
	}
	[Serializable]
	public sealed class SubordinateTransaction : Transaction
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public SubordinateTransaction(IsolationLevel isoLevel, ISimpleTransactionSuperior superior)
		{
			throw null;
		}
	}
	[Serializable]
	public class Transaction : IDisposable, ISerializable
	{
		private delegate void AsyncCommit();

		[ThreadStatic]
		private static Transaction ambient;

		private IsolationLevel level;

		private TransactionInformation info;

		private ArrayList dependents;

		private List<IEnlistmentNotification> volatiles;

		private List<ISinglePhaseNotification> durables;

		private IPromotableSinglePhaseNotification pspe;

		private AsyncCommit asyncCommit;

		private bool committing;

		private bool committed;

		private bool aborted;

		private TransactionScope scope;

		private Exception innerException;

		private Guid tag;

		internal List<IEnlistmentNotification> Volatiles
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		internal List<ISinglePhaseNotification> Durables
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		internal IPromotableSinglePhaseNotification Pspe
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		public static Transaction Current
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		internal static Transaction CurrentInternal
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		public IsolationLevel IsolationLevel
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		public TransactionInformation TransactionInformation
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		public Guid PromoterType
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		private bool Aborted
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		internal TransactionScope Scope
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		public event TransactionCompletedEventHandler TransactionCompleted
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			[CompilerGenerated]
			add
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			[CompilerGenerated]
			remove
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal Transaction()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal Transaction(Transaction other)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public Transaction Clone()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Dispose()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public DependentTransaction DependentClone(DependentCloneOption cloneOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("Only SinglePhase commit supported for durable resource managers.")]
		[PermissionSet(SecurityAction.LinkDemand)]
		public Enlistment EnlistDurable(Guid resourceManagerIdentifier, IEnlistmentNotification enlistmentNotification, EnlistmentOptions enlistmentOptions)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("Only Local Transaction Manager supported. Cannot have more than 1 durable resource per transaction. Only EnlistmentOptions.None supported yet.")]
		[PermissionSet(SecurityAction.LinkDemand)]
		public Enlistment EnlistDurable(Guid resourceManagerIdentifier, ISinglePhaseNotification singlePhaseNotification, EnlistmentOptions enlistmentOptions)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public bool EnlistPromotableSinglePhase(IPromotableSinglePhaseNotification promotableSinglePhaseNotification)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void SetDistributedTransactionIdentifier(IPromotableSinglePhaseNotification promotableNotification, Guid distributedTransactionIdentifier)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public bool EnlistPromotableSinglePhase(IPromotableSinglePhaseNotification promotableSinglePhaseNotification, Guid promoterType)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public byte[] GetPromotedToken()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("EnlistmentOptions being ignored")]
		public Enlistment EnlistVolatile(IEnlistmentNotification enlistmentNotification, EnlistmentOptions enlistmentOptions)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("EnlistmentOptions being ignored")]
		public Enlistment EnlistVolatile(ISinglePhaseNotification singlePhaseNotification, EnlistmentOptions enlistmentOptions)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private Enlistment EnlistVolatileInternal(IEnlistmentNotification notification, EnlistmentOptions options)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("Only Local Transaction Manager supported. Cannot have more than 1 durable resource per transaction.")]
		[PermissionSet(SecurityAction.LinkDemand)]
		public Enlistment PromoteAndEnlistDurable(Guid manager, IPromotableSinglePhaseNotification promotableNotification, ISinglePhaseNotification notification, EnlistmentOptions options)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override bool Equals(object obj)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private bool Equals(Transaction t)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static bool operator ==(Transaction x, Transaction y)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static bool operator !=(Transaction x, Transaction y)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override int GetHashCode()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Rollback()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Rollback(Exception e)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal void Rollback(Exception ex, object abortingEnlisted)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected IAsyncResult BeginCommitInternal(AsyncCallback callback)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected void EndCommitInternal(IAsyncResult ar)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal void CommitInternal()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void DoCommit()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void Complete()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal void InitScope(TransactionScope scope)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void PrepareCallbackWrapper(object state)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void DoPreparePhase()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void DoCommitPhase()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void DoSingleCommit(ISinglePhaseNotification single)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void DoSingleCommit(IPromotableSinglePhaseNotification single)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void CheckAborted()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void FireCompleted()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void EnsureIncompleteCurrentScope()
		{
			throw null;
		}
	}
	[Serializable]
	public class TransactionAbortedException : TransactionException
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionAbortedException()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionAbortedException(string message)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionAbortedException(string message, Exception innerException)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected TransactionAbortedException(SerializationInfo info, StreamingContext context)
		{
			throw null;
		}
	}
	public class TransactionEventArgs : EventArgs
	{
		private Transaction transaction;

		public Transaction Transaction
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionEventArgs()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal TransactionEventArgs(Transaction transaction)
		{
			throw null;
		}
	}
	[Serializable]
	public class TransactionException : SystemException
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionException()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionException(string message)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionException(string message, Exception innerException)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected TransactionException(SerializationInfo info, StreamingContext context)
		{
			throw null;
		}
	}
	[Serializable]
	public class TransactionInDoubtException : TransactionException
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionInDoubtException()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionInDoubtException(string message)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionInDoubtException(string message, Exception innerException)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected TransactionInDoubtException(SerializationInfo info, StreamingContext context)
		{
			throw null;
		}
	}
	public class TransactionInformation
	{
		private string local_id;

		private Guid dtcId;

		private DateTime creation_time;

		private TransactionStatus status;

		public DateTime CreationTime
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		public Guid DistributedIdentifier
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			internal set
			{
				throw null;
			}
		}

		public string LocalIdentifier
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		public TransactionStatus Status
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			internal set
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal TransactionInformation()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private TransactionInformation(TransactionInformation other)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal TransactionInformation Clone(TransactionInformation other)
		{
			throw null;
		}
	}
	[MonoTODO]
	public static class TransactionInterop
	{
		public static readonly Guid PromoterTypeDtc;

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public static IDtcTransaction GetDtcTransaction(Transaction transaction)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public static byte[] GetExportCookie(Transaction transaction, byte[] whereabouts)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public static Transaction GetTransactionFromDtcTransaction(IDtcTransaction transactionNative)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public static Transaction GetTransactionFromExportCookie(byte[] cookie)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public static Transaction GetTransactionFromTransmitterPropagationToken(byte[] propagationToken)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public static byte[] GetTransmitterPropagationToken(Transaction transaction)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO]
		public static byte[] GetWhereabouts()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		static TransactionInterop()
		{
			throw null;
		}
	}
	public static class TransactionManager
	{
		private static TimeSpan defaultTimeout;

		private static TimeSpan maxTimeout;

		public static TimeSpan DefaultTimeout
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		[MonoTODO("Not implemented")]
		public static HostCurrentTransactionCallback HostCurrentCallback
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		public static TimeSpan MaximumTimeout
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		public static event TransactionStartedEventHandler DistributedTransactionStarted
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			[CompilerGenerated]
			add
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			[CompilerGenerated]
			remove
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		static TransactionManager()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("Not implemented")]
		public static void RecoveryComplete(Guid resourceManagerIdentifier)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("Not implemented")]
		public static Enlistment Reenlist(Guid resourceManagerIdentifier, byte[] recoveryInformation, IEnlistmentNotification enlistmentNotification)
		{
			throw null;
		}
	}
	[Serializable]
	public class TransactionManagerCommunicationException : TransactionException
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionManagerCommunicationException()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionManagerCommunicationException(string message)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionManagerCommunicationException(string message, Exception innerException)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected TransactionManagerCommunicationException(SerializationInfo info, StreamingContext context)
		{
			throw null;
		}
	}
	public struct TransactionOptions
	{
		private IsolationLevel level;

		private TimeSpan timeout;

		public IsolationLevel IsolationLevel
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		public TimeSpan Timeout
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal TransactionOptions(IsolationLevel level, TimeSpan timeout)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static bool operator ==(TransactionOptions x, TransactionOptions y)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static bool operator !=(TransactionOptions x, TransactionOptions y)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override bool Equals(object obj)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override int GetHashCode()
		{
			throw null;
		}
	}
	[Serializable]
	public class TransactionPromotionException : TransactionException
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionPromotionException()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionPromotionException(string message)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionPromotionException(string message, Exception innerException)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected TransactionPromotionException(SerializationInfo info, StreamingContext context)
		{
			throw null;
		}
	}
	public sealed class TransactionScope : IDisposable
	{
		private static TransactionOptions defaultOptions;

		private Transaction transaction;

		private Transaction oldTransaction;

		private TransactionScope parentScope;

		private TimeSpan timeout;

		private int nested;

		private bool disposed;

		private bool completed;

		private bool isRoot;

		private bool asyncFlowEnabled;

		internal bool IsComplete
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		internal TimeSpan Timeout
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(TransactionScopeAsyncFlowOption asyncFlowOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(Transaction transactionToUse)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(Transaction transactionToUse, TimeSpan scopeTimeout)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("EnterpriseServicesInteropOption not supported.")]
		public TransactionScope(Transaction transactionToUse, TimeSpan scopeTimeout, EnterpriseServicesInteropOption interopOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(TransactionScopeOption scopeOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(TransactionScopeOption scopeOption, TimeSpan scopeTimeout)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(TransactionScopeOption option, TransactionScopeAsyncFlowOption asyncFlow)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(TransactionScopeOption scopeOption, TimeSpan scopeTimeout, TransactionScopeAsyncFlowOption asyncFlow)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(TransactionScopeOption scopeOption, TransactionOptions transactionOptions)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MonoTODO("EnterpriseServicesInteropOption not supported")]
		public TransactionScope(TransactionScopeOption scopeOption, TransactionOptions transactionOptions, EnterpriseServicesInteropOption interopOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(Transaction transactionToUse, TransactionScopeAsyncFlowOption asyncFlowOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(Transaction transactionToUse, TimeSpan scopeTimeout, TransactionScopeAsyncFlowOption asyncFlowOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionScope(TransactionScopeOption scopeOption, TransactionOptions transactionOptions, TransactionScopeAsyncFlowOption asyncFlowOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void Initialize(TransactionScopeOption scopeOption, Transaction tx, TransactionOptions options, EnterpriseServicesInteropOption interop, TimeSpan scopeTimeout, TransactionScopeAsyncFlowOption asyncFlow)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private Transaction InitTransaction(Transaction tx, TransactionScopeOption scopeOption)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Complete()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void Dispose()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		static TransactionScope()
		{
			throw null;
		}
	}
	public enum TransactionScopeAsyncFlowOption
	{
		Suppress,
		Enabled
	}
	public enum TransactionScopeOption
	{
		Required,
		RequiresNew,
		Suppress
	}
	public enum TransactionStatus
	{
		Active,
		Committed,
		Aborted,
		InDoubt
	}
	[Serializable]
	public sealed class DistributedTransactionPermission : CodeAccessPermission, IUnrestrictedPermission
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public DistributedTransactionPermission(PermissionState state)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override IPermission Copy()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override void FromXml(SecurityElement securityElement)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override IPermission Intersect(IPermission target)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override bool IsSubsetOf(IPermission target)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public bool IsUnrestricted()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override SecurityElement ToXml()
		{
			throw null;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
	public sealed class DistributedTransactionPermissionAttribute : CodeAccessSecurityAttribute
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public DistributedTransactionPermissionAttribute(SecurityAction action)
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override IPermission CreatePermission()
		{
			throw null;
		}
	}
}
namespace System.Transactions.Configuration
{
	public sealed class DefaultSettingsSection : ConfigurationSection
	{
		public string DistributedTransactionManagerName
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		protected override ConfigurationPropertyCollection Properties
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		public TimeSpan Timeout
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public DefaultSettingsSection()
		{
			throw null;
		}
	}
	public sealed class MachineSettingsSection : ConfigurationSection
	{
		public TimeSpan MaxTimeout
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
			[MethodImpl(MethodImplOptions.NoInlining)]
			set
			{
				throw null;
			}
		}

		protected override ConfigurationPropertyCollection Properties
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public MachineSettingsSection()
		{
			throw null;
		}
	}
	public sealed class TransactionsSectionGroup : ConfigurationSectionGroup
	{
		public DefaultSettingsSection DefaultSettings
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		public MachineSettingsSection MachineSettings
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				throw null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public TransactionsSectionGroup()
		{
			throw null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static TransactionsSectionGroup GetSectionGroup(Configuration config)
		{
			throw null;
		}
	}
}
namespace Unity
{
	internal sealed class ThrowStub : ObjectDisposedException
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowNotSupportedException()
		{
			throw null;
		}
	}
}