using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.ServiceModel;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("System.ServiceModel.Duplex")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("System.ServiceModel.Duplex")]
[assembly: AssemblyFileVersion("10.0.25.52802")]
[assembly: AssemblyInformationalVersion("10.0.0+e9d8c1c2a051618689bc22ab263f6ff0f2493d64")]
[assembly: AssemblyProduct("Microsoft® .NET Core")]
[assembly: AssemblyTitle("System.ServiceModel.Duplex")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/wcf")]
[assembly: AssemblyVersion("10.0.0.0")]
[assembly: TypeForwardedTo(typeof(CallbackBehaviorAttribute))]
[assembly: TypeForwardedTo(typeof(ConcurrencyMode))]
[assembly: TypeForwardedTo(typeof(DuplexChannelFactory<>))]
[assembly: TypeForwardedTo(typeof(DuplexClientBase<>))]
[assembly: TypeForwardedTo(typeof(InstanceContext))]

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IdentityModel.Claims;
using System.IdentityModel.Policy;
using System.IdentityModel.Selectors;
using System.IdentityModel.Tokens;
using System.Net;
using System.Net.Security;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Security.Permissions;
using System.Security.Principal;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
using System.ServiceModel.Security;
using System.ServiceModel.Security.Tokens;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("System.ServiceModel.Primitives")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("System.ServiceModel.Primitives")]
[assembly: AssemblyFileVersion("10.0.25.52802")]
[assembly: AssemblyInformationalVersion("10.0.0+e9d8c1c2a051618689bc22ab263f6ff0f2493d64")]
[assembly: AssemblyProduct("Microsoft® .NET Core")]
[assembly: AssemblyTitle("System.ServiceModel.Primitives")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/wcf")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("10.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace System.ServiceModel
{
	public class ActionNotSupportedException : CommunicationException
	{
		public ActionNotSupportedException()
		{
		}

		public ActionNotSupportedException(string message)
		{
		}

		public ActionNotSupportedException(string message, Exception innerException)
		{
		}

		protected ActionNotSupportedException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public enum CacheSetting
	{
		Default,
		AlwaysOn,
		AlwaysOff
	}
	public abstract class ChannelFactory : CommunicationObject, IDisposable, IChannelFactory, ICommunicationObject
	{
		public ClientCredentials Credentials => null;

		protected override TimeSpan DefaultCloseTimeout => default(TimeSpan);

		protected override TimeSpan DefaultOpenTimeout => default(TimeSpan);

		public ServiceEndpoint Endpoint => null;

		protected abstract ServiceEndpoint CreateDescription();

		protected virtual IChannelFactory CreateFactory()
		{
			return null;
		}

		protected internal void EnsureOpened()
		{
		}

		public T GetProperty<T>() where T : class
		{
			return null;
		}

		protected void InitializeEndpoint(Binding binding, EndpointAddress address)
		{
		}

		protected void InitializeEndpoint(ServiceEndpoint endpoint)
		{
		}

		protected override void OnAbort()
		{
		}

		protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		protected override void OnClose(TimeSpan timeout)
		{
		}

		protected override void OnEndClose(IAsyncResult result)
		{
		}

		protected override void OnEndOpen(IAsyncResult result)
		{
		}

		protected override void OnOpen(TimeSpan timeout)
		{
		}

		protected override void OnOpened()
		{
		}

		protected override void OnOpening()
		{
		}

		void IDisposable.Dispose()
		{
		}
	}
	public class ChannelFactory<TChannel> : ChannelFactory, IChannelFactory, ICommunicationObject, IChannelFactory<TChannel>
	{
		public ChannelFactory(Binding binding)
		{
		}

		public ChannelFactory(Binding binding, EndpointAddress remoteAddress)
		{
		}

		public ChannelFactory(ServiceEndpoint endpoint)
		{
		}

		protected ChannelFactory(Type channelType)
		{
		}

		public TChannel CreateChannel()
		{
			return default(TChannel);
		}

		public TChannel CreateChannel(EndpointAddress address)
		{
			return default(TChannel);
		}

		public virtual TChannel CreateChannel(EndpointAddress address, Uri via)
		{
			return default(TChannel);
		}

		protected override ServiceEndpoint CreateDescription()
		{
			return null;
		}
	}
	public class ChannelTerminatedException : CommunicationException
	{
		public ChannelTerminatedException()
		{
		}

		public ChannelTerminatedException(string message)
		{
		}

		public ChannelTerminatedException(string message, Exception innerException)
		{
		}

		protected ChannelTerminatedException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public abstract class ClientBase<TChannel> : IDisposable, ICommunicationObject where TChannel : class
	{
		protected delegate IAsyncResult BeginOperationDelegate(object[] inValues, AsyncCallback asyncCallback, object state);

		protected class ChannelBase<T> : IDisposable, IChannel, ICommunicationObject, IOutputChannel, IRequestChannel, IClientChannel, IContextChannel, IExtensibleObject<IContextChannel> where T : class
		{
			EndpointAddress IOutputChannel.RemoteAddress => null;

			Uri IOutputChannel.Via => null;

			EndpointAddress IRequestChannel.RemoteAddress => null;

			Uri IRequestChannel.Via => null;

			bool IClientChannel.AllowInitializationUI
			{
				get
				{
					return false;
				}
				set
				{
				}
			}

			bool IClientChannel.DidInteractiveInitialization => false;

			Uri IClientChannel.Via => null;

			CommunicationState ICommunicationObject.State => CommunicationState.Created;

			bool IContextChannel.AllowOutputBatching
			{
				get
				{
					return false;
				}
				set
				{
				}
			}

			IInputSession IContextChannel.InputSession => null;

			EndpointAddress IContextChannel.LocalAddress => null;

			TimeSpan IContextChannel.OperationTimeout
			{
				get
				{
					return default(TimeSpan);
				}
				set
				{
				}
			}

			IOutputSession IContextChannel.OutputSession => null;

			EndpointAddress IContextChannel.RemoteAddress => null;

			string IContextChannel.SessionId => null;

			IExtensionCollection<IContextChannel> IExtensibleObject<IContextChannel>.Extensions => null;

			event EventHandler<UnknownMessageReceivedEventArgs> IClientChannel.UnknownMessageReceived
			{
				add
				{
				}
				remove
				{
				}
			}

			event EventHandler ICommunicationObject.Closed
			{
				add
				{
				}
				remove
				{
				}
			}

			event EventHandler ICommunicationObject.Closing
			{
				add
				{
				}
				remove
				{
				}
			}

			event EventHandler ICommunicationObject.Faulted
			{
				add
				{
				}
				remove
				{
				}
			}

			event EventHandler ICommunicationObject.Opened
			{
				add
				{
				}
				remove
				{
				}
			}

			event EventHandler ICommunicationObject.Opening
			{
				add
				{
				}
				remove
				{
				}
			}

			protected ChannelBase(ClientBase<T> client)
			{
			}

			protected IAsyncResult BeginInvoke(string methodName, object[] args, AsyncCallback callback, object state)
			{
				return null;
			}

			protected object EndInvoke(string methodName, object[] args, IAsyncResult result)
			{
				return null;
			}

			void IDisposable.Dispose()
			{
			}

			TProperty IChannel.GetProperty<TProperty>()
			{
				return null;
			}

			IAsyncResult IOutputChannel.BeginSend(Message message, AsyncCallback callback, object state)
			{
				return null;
			}

			IAsyncResult IOutputChannel.BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state)
			{
				return null;
			}

			void IOutputChannel.EndSend(IAsyncResult result)
			{
			}

			void IOutputChannel.Send(Message message)
			{
			}

			void IOutputChannel.Send(Message message, TimeSpan timeout)
			{
			}

			IAsyncResult IRequestChannel.BeginRequest(Message message, AsyncCallback callback, object state)
			{
				return null;
			}

			IAsyncResult IRequestChannel.BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state)
			{
				return null;
			}

			Message IRequestChannel.EndRequest(IAsyncResult result)
			{
				return null;
			}

			Message IRequestChannel.Request(Message message)
			{
				return null;
			}

			Message IRequestChannel.Request(Message message, TimeSpan timeout)
			{
				return null;
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			IAsyncResult IClientChannel.BeginDisplayInitializationUI(AsyncCallback callback, object state)
			{
				return null;
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			void IClientChannel.DisplayInitializationUI()
			{
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			void IClientChannel.EndDisplayInitializationUI(IAsyncResult result)
			{
			}

			void ICommunicationObject.Abort()
			{
			}

			IAsyncResult ICommunicationObject.BeginClose(AsyncCallback callback, object state)
			{
				return null;
			}

			IAsyncResult ICommunicationObject.BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
			{
				return null;
			}

			IAsyncResult ICommunicationObject.BeginOpen(AsyncCallback callback, object state)
			{
				return null;
			}

			IAsyncResult ICommunicationObject.BeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
			{
				return null;
			}

			void ICommunicationObject.Close()
			{
			}

			void ICommunicationObject.Close(TimeSpan timeout)
			{
			}

			void ICommunicationObject.EndClose(IAsyncResult result)
			{
			}

			void ICommunicationObject.EndOpen(IAsyncResult result)
			{
			}

			void ICommunicationObject.Open()
			{
			}

			void ICommunicationObject.Open(TimeSpan timeout)
			{
			}
		}

		protected delegate object[] EndOperationDelegate(IAsyncResult result);

		protected class InvokeAsyncCompletedEventArgs : AsyncCompletedEventArgs
		{
			public object[] Results => null;

			internal InvokeAsyncCompletedEventArgs()
				: base(null, cancelled: false, null)
			{
			}
		}

		protected TChannel Channel => null;

		public static CacheSetting CacheSetting
		{
			get
			{
				return CacheSetting.Default;
			}
			set
			{
			}
		}

		public ChannelFactory<TChannel> ChannelFactory => null;

		public ClientCredentials ClientCredentials => null;

		public ServiceEndpoint Endpoint => null;

		public IClientChannel InnerChannel => null;

		public CommunicationState State => CommunicationState.Created;

		event EventHandler ICommunicationObject.Closed
		{
			add
			{
			}
			remove
			{
			}
		}

		event EventHandler ICommunicationObject.Closing
		{
			add
			{
			}
			remove
			{
			}
		}

		event EventHandler ICommunicationObject.Faulted
		{
			add
			{
			}
			remove
			{
			}
		}

		event EventHandler ICommunicationObject.Opened
		{
			add
			{
			}
			remove
			{
			}
		}

		event EventHandler ICommunicationObject.Opening
		{
			add
			{
			}
			remove
			{
			}
		}

		protected ClientBase()
		{
		}

		protected ClientBase(Binding binding, EndpointAddress remoteAddress)
		{
		}

		protected ClientBase(ServiceEndpoint endpoint)
		{
		}

		public void Abort()
		{
		}

		public void Close()
		{
		}

		public void Open()
		{
		}

		protected virtual TChannel CreateChannel()
		{
			return null;
		}

		protected T GetDefaultValueForInitialization<T>()
		{
			return default(T);
		}

		protected void InvokeAsync(BeginOperationDelegate beginOperationDelegate, object[] inValues, EndOperationDelegate endOperationDelegate, SendOrPostCallback operationCompletedCallback, object userState)
		{
		}

		IAsyncResult ICommunicationObject.BeginClose(AsyncCallback callback, object state)
		{
			return null;
		}

		IAsyncResult ICommunicationObject.BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		IAsyncResult ICommunicationObject.BeginOpen(AsyncCallback callback, object state)
		{
			return null;
		}

		IAsyncResult ICommunicationObject.BeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		void ICommunicationObject.Close()
		{
		}

		void ICommunicationObject.Close(TimeSpan timeout)
		{
		}

		void ICommunicationObject.EndClose(IAsyncResult result)
		{
		}

		void ICommunicationObject.EndOpen(IAsyncResult result)
		{
		}

		void ICommunicationObject.Open()
		{
		}

		void ICommunicationObject.Open(TimeSpan timeout)
		{
		}

		void IDisposable.Dispose()
		{
		}
	}
	public class ClientCredentialsSecurityTokenManager : SecurityTokenManager
	{
		public ClientCredentials ClientCredentials => null;

		public ClientCredentialsSecurityTokenManager(ClientCredentials clientCredentials)
		{
		}

		public override SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement)
		{
			return null;
		}

		public override SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version)
		{
			return null;
		}

		public override SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver)
		{
			outOfBandTokenResolver = null;
			return null;
		}
	}
	public class CommunicationException : Exception
	{
		public CommunicationException()
		{
		}

		public CommunicationException(string message)
		{
		}

		public CommunicationException(string message, Exception innerException)
		{
		}

		protected CommunicationException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public class CommunicationObjectAbortedException : CommunicationException
	{
		public CommunicationObjectAbortedException()
		{
		}

		public CommunicationObjectAbortedException(string message)
		{
		}

		public CommunicationObjectAbortedException(string message, Exception innerException)
		{
		}

		protected CommunicationObjectAbortedException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public class CommunicationObjectFaultedException : CommunicationException
	{
		public CommunicationObjectFaultedException()
		{
		}

		public CommunicationObjectFaultedException(string message)
		{
		}

		public CommunicationObjectFaultedException(string message, Exception innerException)
		{
		}

		protected CommunicationObjectFaultedException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public enum CommunicationState
	{
		Closed = 4,
		Closing = 3,
		Created = 0,
		Faulted = 5,
		Opened = 2,
		Opening = 1
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]
	public sealed class DataContractFormatAttribute : Attribute
	{
		public OperationFormatStyle Style
		{
			get
			{
				return OperationFormatStyle.Document;
			}
			set
			{
			}
		}
	}
	public sealed class DeliveryRequirementsAttribute : Attribute, IContractBehavior
	{
		public QueuedDeliveryRequirementsMode QueuedDeliveryRequirements { get; set; }

		public bool RequireOrderedDelivery { get; set; }

		void IContractBehavior.AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
		{
		}

		void IContractBehavior.ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, ClientRuntime clientRuntime)
		{
		}

		void IContractBehavior.ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
		{
		}

		void IContractBehavior.Validate(ContractDescription contractDescription, ServiceEndpoint endpoint)
		{
		}
	}
	public class EndpointAddress
	{
		public static Uri AnonymousUri => null;

		public AddressHeaderCollection Headers => null;

		public EndpointIdentity Identity => null;

		public bool IsAnonymous => false;

		public bool IsNone => false;

		public static Uri NoneUri => null;

		public Uri Uri => null;

		public EndpointAddress(string uri)
		{
		}

		public EndpointAddress(Uri uri, params AddressHeader[] addressHeaders)
		{
		}

		public EndpointAddress(Uri uri, EndpointIdentity identity, params AddressHeader[] addressHeaders)
		{
		}

		public void ApplyTo(Message message)
		{
		}

		public override bool Equals(object obj)
		{
			return false;
		}

		public override int GetHashCode()
		{
			return 0;
		}

		public static bool operator ==(EndpointAddress address1, EndpointAddress address2)
		{
			return false;
		}

		public static bool operator !=(EndpointAddress address1, EndpointAddress address2)
		{
			return false;
		}

		public static EndpointAddress ReadFrom(AddressingVersion addressingVersion, XmlDictionaryReader reader)
		{
			return null;
		}

		public override string ToString()
		{
			return null;
		}

		public void WriteContentsTo(AddressingVersion addressingVersion, XmlDictionaryWriter writer)
		{
		}
	}
	public class EndpointAddressBuilder
	{
		public Collection<AddressHeader> Headers => null;

		public EndpointIdentity Identity
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public Uri Uri
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public EndpointAddressBuilder()
		{
		}

		public EndpointAddressBuilder(EndpointAddress address)
		{
		}

		public EndpointAddress ToEndpointAddress()
		{
			return null;
		}
	}
	public abstract class EndpointIdentity
	{
		public Claim IdentityClaim => null;

		protected void Initialize(Claim identityClaim)
		{
		}

		protected void Initialize(Claim identityClaim, IEqualityComparer<Claim> claimComparer)
		{
		}

		public override bool Equals(object obj)
		{
			return false;
		}

		public override int GetHashCode()
		{
			return 0;
		}

		public override string ToString()
		{
			return null;
		}

		public static EndpointIdentity CreateIdentity(Claim identity)
		{
			return null;
		}
	}
	public class EndpointNotFoundException : CommunicationException
	{
		public EndpointNotFoundException(string message)
		{
		}

		public EndpointNotFoundException(string message, Exception innerException)
		{
		}

		protected EndpointNotFoundException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public sealed class EnvelopeVersion
	{
		public string NextDestinationActorValue => null;

		public static EnvelopeVersion None => null;

		public static EnvelopeVersion Soap11 => null;

		public static EnvelopeVersion Soap12 => null;

		internal EnvelopeVersion()
		{
		}

		public string[] GetUltimateDestinationActorValues()
		{
			return null;
		}

		public override string ToString()
		{
			return null;
		}
	}
	[DataContract]
	public class ExceptionDetail
	{
		[DataMember]
		public string HelpLink
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DataMember]
		public ExceptionDetail InnerException
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DataMember]
		public string Message
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DataMember]
		public string StackTrace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DataMember]
		public string Type
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public ExceptionDetail(Exception exception)
		{
		}

		public override string ToString()
		{
			return null;
		}
	}
	public sealed class ExtensionCollection<T> : SynchronizedCollection<IExtension<T>>, IExtensionCollection<T>, ICollection<IExtension<T>>, IEnumerable<IExtension<T>>, IEnumerable where T : IExtensibleObject<T>
	{
		public ExtensionCollection(T owner)
		{
		}

		public ExtensionCollection(T owner, object syncRoot)
			: base(syncRoot)
		{
		}

		protected override void ClearItems()
		{
		}

		public E Find<E>()
		{
			return default(E);
		}

		public Collection<E> FindAll<E>()
		{
			return null;
		}

		protected override void InsertItem(int index, IExtension<T> item)
		{
		}

		protected override void RemoveItem(int index)
		{
		}

		protected override void SetItem(int index, IExtension<T> item)
		{
		}
	}
	public class FaultCode
	{
		public bool IsPredefinedFault => false;

		public bool IsReceiverFault => false;

		public bool IsSenderFault => false;

		public string Name => null;

		public string Namespace => null;

		public FaultCode SubCode => null;

		public FaultCode(string name)
		{
		}

		public FaultCode(string name, FaultCode subCode)
		{
		}

		public FaultCode(string name, string ns)
		{
		}

		public FaultCode(string name, string ns, FaultCode subCode)
		{
		}

		public static FaultCode CreateSenderFaultCode(FaultCode subCode)
		{
			return null;
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
	public sealed class FaultContractAttribute : Attribute
	{
		public string Action
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public Type DetailType => null;

		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Namespace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public FaultContractAttribute(Type detailType)
		{
		}
	}
	[Serializable]
	public class FaultException : CommunicationException
	{
		public string Action => null;

		public FaultCode Code => null;

		public override string Message => null;

		public FaultReason Reason => null;

		public FaultException()
		{
		}

		public FaultException(string reason)
		{
		}

		public FaultException(MessageFault fault, string action)
		{
		}

		public FaultException(FaultReason reason, FaultCode code, string action)
		{
		}

		protected FaultException(SerializationInfo info, StreamingContext context)
		{
		}

		public static FaultException CreateFault(MessageFault messageFault, string action, params Type[] faultDetailTypes)
		{
			return null;
		}

		public static FaultException CreateFault(MessageFault messageFault, params Type[] faultDetailTypes)
		{
			return null;
		}

		public virtual MessageFault CreateMessageFault()
		{
			return null;
		}
	}
	[Serializable]
	public class FaultException<TDetail> : FaultException
	{
		public TDetail Detail => default(TDetail);

		public FaultException(TDetail detail)
		{
		}

		public FaultException(TDetail detail, FaultReason reason)
		{
		}

		public FaultException(TDetail detail, FaultReason reason, FaultCode code, string action)
		{
		}

		public FaultException(TDetail detail, FaultReason reason, FaultCode code)
		{
		}

		public FaultException(TDetail detail, string reason)
		{
		}

		public FaultException(TDetail detail, string reason, FaultCode code)
		{
		}

		public FaultException(TDetail detail, string reason, FaultCode code, string action)
		{
		}

		protected FaultException(SerializationInfo info, StreamingContext context)
		{
		}

		public override MessageFault CreateMessageFault()
		{
			return null;
		}

		public override string ToString()
		{
			return null;
		}
	}
	public class FaultReason
	{
		public FaultReason(IEnumerable<FaultReasonText> translations)
		{
		}

		public FaultReason(FaultReasonText translation)
		{
		}

		public FaultReason(string text)
		{
		}

		public FaultReasonText GetMatchingTranslation()
		{
			return null;
		}

		public FaultReasonText GetMatchingTranslation(CultureInfo cultureInfo)
		{
			return null;
		}

		public override string ToString()
		{
			return null;
		}
	}
	public class FaultReasonText
	{
		public string Text => null;

		public string XmlLang => null;

		public FaultReasonText(string text)
		{
		}

		public FaultReasonText(string text, string xmlLang)
		{
		}

		public bool Matches(CultureInfo cultureInfo)
		{
			return false;
		}
	}
	public enum HostNameComparisonMode
	{
		StrongWildcard,
		Exact,
		WeakWildcard
	}
	public interface IClientChannel : IDisposable, IChannel, ICommunicationObject, IContextChannel, IExtensibleObject<IContextChannel>
	{
		bool AllowInitializationUI { get; set; }

		bool DidInteractiveInitialization { get; }

		Uri Via { get; }

		event EventHandler<UnknownMessageReceivedEventArgs> UnknownMessageReceived;

		IAsyncResult BeginDisplayInitializationUI(AsyncCallback callback, object state);

		void DisplayInitializationUI();

		void EndDisplayInitializationUI(IAsyncResult result);
	}
	public interface ICommunicationObject
	{
		CommunicationState State { get; }

		event EventHandler Closed;

		event EventHandler Closing;

		event EventHandler Faulted;

		event EventHandler Opened;

		event EventHandler Opening;

		void Abort();

		IAsyncResult BeginClose(AsyncCallback callback, object state);

		IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state);

		IAsyncResult BeginOpen(AsyncCallback callback, object state);

		IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, object state);

		void Close();

		void Close(TimeSpan timeout);

		void EndClose(IAsyncResult result);

		void EndOpen(IAsyncResult result);

		void Open();

		void Open(TimeSpan timeout);
	}
	public interface IContextChannel : IChannel, ICommunicationObject, IExtensibleObject<IContextChannel>
	{
		bool AllowOutputBatching { get; set; }

		IInputSession InputSession { get; }

		EndpointAddress LocalAddress { get; }

		TimeSpan OperationTimeout { get; set; }

		IOutputSession OutputSession { get; }

		EndpointAddress RemoteAddress { get; }

		string SessionId { get; }
	}
	public interface IDefaultCommunicationTimeouts
	{
		TimeSpan CloseTimeout { get; }

		TimeSpan OpenTimeout { get; }

		TimeSpan ReceiveTimeout { get; }

		TimeSpan SendTimeout { get; }
	}
	public interface IExtensibleObject<T> where T : IExtensibleObject<T>
	{
		IExtensionCollection<T> Extensions { get; }
	}
	public interface IExtension<T> where T : IExtensibleObject<T>
	{
		void Attach(T owner);

		void Detach(T owner);
	}
	public interface IExtensionCollection<T> : ICollection<IExtension<T>>, IEnumerable<IExtension<T>>, IEnumerable where T : IExtensibleObject<T>
	{
		E Find<E>();

		Collection<E> FindAll<E>();
	}
	public class InvalidMessageContractException : Exception
	{
		public InvalidMessageContractException()
		{
		}

		public InvalidMessageContractException(string message)
		{
		}

		public InvalidMessageContractException(string message, Exception innerException)
		{
		}

		protected InvalidMessageContractException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	public class MessageHeaderAttribute : MessageContractMemberAttribute
	{
		public bool MustUnderstand
		{
			get
			{
				return false;
			}
			set
			{
			}
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	public sealed class MessageHeaderArrayAttribute : MessageHeaderAttribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, Inherited = false)]
	public class MessageBodyMemberAttribute : MessageContractMemberAttribute
	{
		public int Order
		{
			get
			{
				return 0;
			}
			set
			{
			}
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false)]
	public sealed class MessageContractAttribute : Attribute
	{
		public bool IsWrapped
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public string WrapperName
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string WrapperNamespace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}
	}
	public abstract class MessageContractMemberAttribute : Attribute
	{
		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Namespace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	public sealed class MessagePropertyAttribute : Attribute
	{
		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}
	}
	public enum MessageCredentialType
	{
		Certificate = 3,
		IssuedToken = 4,
		None = 0,
		UserName = 2,
		Windows = 1
	}
	public class MessageHeader<T>
	{
		public string Actor
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public T Content
		{
			get
			{
				return default(T);
			}
			set
			{
			}
		}

		public bool MustUnderstand
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public bool Relay
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public MessageHeader()
		{
		}

		public MessageHeader(T content)
		{
		}

		public MessageHeader(T content, bool mustUnderstand, string actor, bool relay)
		{
		}

		public MessageHeader GetUntypedHeader(string name, string ns)
		{
			return null;
		}
	}
	public class MessageHeaderException : ProtocolException
	{
		public string HeaderName => null;

		public string HeaderNamespace => null;

		public bool IsDuplicate => false;

		public MessageHeaderException(string message)
			: base(null)
		{
		}

		public MessageHeaderException(string message, bool isDuplicate)
			: base(null)
		{
		}

		public MessageHeaderException(string message, Exception innerException)
			: base(null)
		{
		}

		public MessageHeaderException(string message, string headerName, string ns)
			: base(null)
		{
		}

		public MessageHeaderException(string message, string headerName, string ns, bool isDuplicate)
			: base(null)
		{
		}

		public MessageHeaderException(string message, string headerName, string ns, bool isDuplicate, Exception innerException)
			: base(null)
		{
		}

		public MessageHeaderException(string message, string headerName, string ns, Exception innerException)
			: base(null)
		{
		}

		protected MessageHeaderException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	public sealed class MessageParameterAttribute : Attribute
	{
		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}
	}
	public sealed class OperationContext : IExtensibleObject<OperationContext>
	{
		public static OperationContext Current
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public IExtensionCollection<OperationContext> Extensions => null;

		public MessageHeaders IncomingMessageHeaders => null;

		public MessageProperties IncomingMessageProperties => null;

		public MessageVersion IncomingMessageVersion => null;

		public bool IsUserContext => false;

		public MessageHeaders OutgoingMessageHeaders => null;

		public MessageProperties OutgoingMessageProperties => null;

		public RequestContext RequestContext
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public IContextChannel Channel => null;

		public event EventHandler OperationCompleted
		{
			add
			{
			}
			remove
			{
			}
		}

		public OperationContext(IContextChannel channel)
		{
		}

		public T GetCallbackChannel<T>()
		{
			return default(T);
		}
	}
	public sealed class OperationContextScope : IDisposable
	{
		public OperationContextScope(IContextChannel channel)
		{
		}

		public OperationContextScope(OperationContext context)
		{
		}

		public void Dispose()
		{
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class OperationContractAttribute : Attribute
	{
		public string Action
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public bool AsyncPattern
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public bool IsInitiating
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public bool IsTerminating
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public bool IsOneWay
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string ReplyAction
		{
			get
			{
				return null;
			}
			set
			{
			}
		}
	}
	public enum OperationFormatStyle
	{
		Document,
		Rpc
	}
	public enum OperationFormatUse
	{
		Literal,
		Encoded
	}
	public class OptionalReliableSession : ReliableSession
	{
		public bool Enabled { get; set; }

		public OptionalReliableSession()
		{
		}

		public OptionalReliableSession(ReliableSessionBindingElement reliableSessionBindingElement)
		{
		}
	}
	public class ProtocolException : CommunicationException
	{
		public ProtocolException(string message)
		{
		}

		public ProtocolException(string message, Exception innerException)
		{
		}

		protected ProtocolException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public enum QueuedDeliveryRequirementsMode
	{
		Allowed,
		Required,
		NotAllowed
	}
	public class QuotaExceededException : Exception
	{
		public QuotaExceededException(string message)
		{
		}

		public QuotaExceededException(string message, Exception innerException)
		{
		}

		protected QuotaExceededException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public abstract class ReliableMessagingVersion
	{
		public static ReliableMessagingVersion Default => null;

		public static ReliableMessagingVersion WSReliableMessaging11 => null;

		public static ReliableMessagingVersion WSReliableMessagingFebruary2005 => null;

		internal ReliableMessagingVersion(string ns, XmlDictionaryString dictionaryNs)
		{
		}
	}
	public class ReliableSession
	{
		public bool Ordered { get; set; }

		public TimeSpan InactivityTimeout { get; set; }

		public ReliableSession()
		{
		}

		public ReliableSession(ReliableSessionBindingElement reliableSessionBindingElement)
		{
		}
	}
	public enum SecurityMode
	{
		Message = 2,
		None = 0,
		Transport = 1,
		TransportWithMessageCredential = 3
	}
	public class ServerTooBusyException : CommunicationException
	{
		public ServerTooBusyException(string message)
		{
		}

		public ServerTooBusyException(string message, Exception innerException)
		{
		}

		protected ServerTooBusyException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public class ServiceActivationException : CommunicationException
	{
		public ServiceActivationException(string message)
		{
		}

		public ServiceActivationException(string message, Exception innerException)
		{
		}

		protected ServiceActivationException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]
	public sealed class ServiceContractAttribute : Attribute
	{
		public Type CallbackContract
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string ConfigurationName
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Namespace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public SessionMode SessionMode
		{
			get
			{
				return SessionMode.Allowed;
			}
			set
			{
			}
		}
	}
	public enum SessionMode
	{
		Allowed,
		Required,
		NotAllowed
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Interface, Inherited = true, AllowMultiple = true)]
	public sealed class ServiceKnownTypeAttribute : Attribute
	{
		public Type DeclaringType => null;

		public string MethodName => null;

		public Type Type => null;

		public ServiceKnownTypeAttribute(string methodName)
		{
		}

		public ServiceKnownTypeAttribute(string methodName, Type declaringType)
		{
		}

		public ServiceKnownTypeAttribute(Type type)
		{
		}
	}
	public enum TransferMode
	{
		Buffered,
		Streamed,
		StreamedRequest,
		StreamedResponse
	}
	public sealed class UnknownMessageReceivedEventArgs : EventArgs
	{
		public Message Message => null;

		internal UnknownMessageReceivedEventArgs()
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]
	public sealed class XmlSerializerFormatAttribute : Attribute
	{
		public OperationFormatStyle Style
		{
			get
			{
				return OperationFormatStyle.Document;
			}
			set
			{
			}
		}

		public bool SupportFaults
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public OperationFormatUse Use
		{
			get
			{
				throw null;
			}
			set
			{
			}
		}
	}
	public sealed class InstanceContext : CommunicationObject, IExtensibleObject<InstanceContext>
	{
		protected override TimeSpan DefaultCloseTimeout => default(TimeSpan);

		protected override TimeSpan DefaultOpenTimeout => default(TimeSpan);

		public SynchronizationContext SynchronizationContext
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public IExtensionCollection<InstanceContext> Extensions => null;

		public InstanceContext(object implementation)
		{
		}

		public object GetServiceInstance(Message message)
		{
			return null;
		}

		protected override void OnAbort()
		{
		}

		protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		protected override void OnClose(TimeSpan timeout)
		{
		}

		protected override void OnClosed()
		{
		}

		protected override void OnEndClose(IAsyncResult result)
		{
		}

		protected override void OnEndOpen(IAsyncResult result)
		{
		}

		protected override void OnFaulted()
		{
		}

		protected override void OnOpen(TimeSpan timeout)
		{
		}

		protected override void OnOpened()
		{
		}

		protected override void OnOpening()
		{
		}
	}
	public class DnsEndpointIdentity : EndpointIdentity
	{
		public DnsEndpointIdentity(string dnsName)
		{
		}
	}
	public abstract class MessageSecurityVersion
	{
		public abstract BasicSecurityProfileVersion BasicSecurityProfileVersion { get; }

		public SecureConversationVersion SecureConversationVersion => null;

		public abstract SecurityPolicyVersion SecurityPolicyVersion { get; }

		public SecurityVersion SecurityVersion => null;

		public TrustVersion TrustVersion => null;

		public static MessageSecurityVersion WSSecurity10WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10 => null;

		public static MessageSecurityVersion WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11 => null;

		public static MessageSecurityVersion WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10 => null;

		public static MessageSecurityVersion WSSecurity11WSTrust13WSSecureConversation13WSSecurityPolicy12BasicSecurityProfile10 => null;

		internal MessageSecurityVersion()
		{
		}
	}
	public class ServiceSecurityContext
	{
		public static ServiceSecurityContext Anonymous => null;

		public bool IsAnonymous => false;

		public IIdentity PrimaryIdentity => null;

		public ReadOnlyCollection<IAuthorizationPolicy> AuthorizationPolicies { get; set; }

		public AuthorizationContext AuthorizationContext => null;

		public ServiceSecurityContext(ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies)
		{
		}

		public ServiceSecurityContext(AuthorizationContext authorizationContext)
		{
		}

		public ServiceSecurityContext(AuthorizationContext authorizationContext, ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies)
		{
		}
	}
	public class SpnEndpointIdentity : EndpointIdentity
	{
		public static TimeSpan SpnLookupTime
		{
			get
			{
				return default(TimeSpan);
			}
			set
			{
			}
		}

		public SpnEndpointIdentity(string spnName)
		{
		}
	}
	public class UpnEndpointIdentity : EndpointIdentity
	{
		public UpnEndpointIdentity(string upnName)
		{
		}
	}
	public class X509CertificateEndpointIdentity : EndpointIdentity
	{
		public X509Certificate2Collection Certificates { get; }

		public X509CertificateEndpointIdentity(X509Certificate2 certificate)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class CallbackBehaviorAttribute : Attribute, IEndpointBehavior
	{
		public bool AutomaticSessionShutdown
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public bool UseSynchronizationContext
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public ConcurrencyMode ConcurrencyMode
		{
			get
			{
				return ConcurrencyMode.Single;
			}
			set
			{
			}
		}

		void IEndpointBehavior.AddBindingParameters(ServiceEndpoint serviceEndpoint, BindingParameterCollection parameters)
		{
		}

		void IEndpointBehavior.ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime clientRuntime)
		{
		}

		void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint serviceEndpoint, EndpointDispatcher endpointDispatcher)
		{
		}

		void IEndpointBehavior.Validate(ServiceEndpoint serviceEndpoint)
		{
		}
	}
	public enum ConcurrencyMode
	{
		Single,
		[Obsolete]
		Reentrant,
		Multiple
	}
	public class DuplexChannelFactory<TChannel> : ChannelFactory<TChannel>
	{
		public DuplexChannelFactory(Type callbackInstanceType)
			: base((Type)null)
		{
		}

		public DuplexChannelFactory(Type callbackInstanceType, Binding binding)
			: base((Type)null)
		{
		}

		public DuplexChannelFactory(Type callbackInstanceType, Binding binding, EndpointAddress remoteAddress)
			: base((Type)null)
		{
		}

		public DuplexChannelFactory(Type callbackInstanceType, Binding binding, string remoteAddress)
			: base((Type)null)
		{
		}

		public DuplexChannelFactory(Type callbackInstanceType, ServiceEndpoint serviceEndpoint)
			: base((Type)null)
		{
		}

		public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding)
			: base((Type)null)
		{
		}

		public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding, EndpointAddress remoteAddress)
			: base((Type)null)
		{
		}

		public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding, string remoteAddress)
			: base((Type)null)
		{
		}

		public override TChannel CreateChannel(EndpointAddress address, Uri via)
		{
			return default(TChannel);
		}

		public TChannel CreateChannel(InstanceContext callbackInstance)
		{
			return default(TChannel);
		}

		public TChannel CreateChannel(InstanceContext callbackInstance, EndpointAddress address)
		{
			return default(TChannel);
		}

		public virtual TChannel CreateChannel(InstanceContext callbackInstance, EndpointAddress address, Uri via)
		{
			return default(TChannel);
		}
	}
	public abstract class DuplexClientBase<TChannel> : ClientBase<TChannel> where TChannel : class
	{
		protected DuplexClientBase(InstanceContext callbackInstance)
		{
		}

		protected DuplexClientBase(InstanceContext callbackInstance, Binding binding, EndpointAddress remoteAddress)
		{
		}
	}
}
namespace System.ServiceModel.Security
{
	public sealed class HttpDigestClientCredential
	{
		public NetworkCredential ClientCredential
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		internal HttpDigestClientCredential()
		{
		}
	}
	public interface ISecuritySession : ISession
	{
		EndpointIdentity RemoteIdentity { get; }
	}
	public class MessageSecurityException : CommunicationException
	{
		public MessageSecurityException(string message)
		{
		}

		public MessageSecurityException(string message, Exception innerException)
		{
		}

		protected MessageSecurityException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public class SecurityAccessDeniedException : CommunicationException
	{
		public SecurityAccessDeniedException(string message)
		{
		}

		public SecurityAccessDeniedException(string message, Exception innerException)
		{
		}

		protected SecurityAccessDeniedException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public abstract class SecurityCredentialsManager
	{
		public abstract SecurityTokenManager CreateSecurityTokenManager();
	}
	public class SecurityNegotiationException : CommunicationException
	{
		public SecurityNegotiationException()
		{
		}

		public SecurityNegotiationException(string message)
		{
		}

		public SecurityNegotiationException(string message, Exception innerException)
		{
		}

		protected SecurityNegotiationException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public sealed class UserNamePasswordClientCredential
	{
		public string Password
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string UserName
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		internal UserNamePasswordClientCredential()
		{
		}
	}
	public sealed class WindowsClientCredential
	{
		public TokenImpersonationLevel AllowedImpersonationLevel
		{
			get
			{
				return TokenImpersonationLevel.None;
			}
			set
			{
			}
		}

		public NetworkCredential ClientCredential
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		internal WindowsClientCredential()
		{
		}
	}
	public sealed class X509ServiceCertificateAuthentication
	{
		public X509CertificateValidationMode CertificateValidationMode
		{
			get
			{
				return X509CertificateValidationMode.None;
			}
			set
			{
			}
		}

		public X509CertificateValidator CustomCertificateValidator
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public X509RevocationMode RevocationMode
		{
			get
			{
				return X509RevocationMode.NoCheck;
			}
			set
			{
			}
		}

		public StoreLocation TrustedStoreLocation
		{
			get
			{
				return (StoreLocation)0;
			}
			set
			{
			}
		}
	}
	public sealed class X509CertificateInitiatorClientCredential
	{
		public X509Certificate2 Certificate
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		internal X509CertificateInitiatorClientCredential()
		{
		}

		public void SetCertificate(StoreLocation storeLocation, StoreName storeName, X509FindType findType, object findValue)
		{
		}

		public void SetCertificate(string subjectName, StoreLocation storeLocation, StoreName storeName)
		{
		}
	}
	public sealed class X509CertificateRecipientClientCredential
	{
		public X509ServiceCertificateAuthentication Authentication => null;

		public X509Certificate2 DefaultCertificate
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public Dictionary<Uri, X509Certificate2> ScopedCertificates => null;

		public X509ServiceCertificateAuthentication SslCertificateAuthentication
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		internal X509CertificateRecipientClientCredential()
		{
		}

		public void SetDefaultCertificate(StoreLocation storeLocation, StoreName storeName, X509FindType findType, object findValue)
		{
		}

		public void SetDefaultCertificate(string subjectName, StoreLocation storeLocation, StoreName storeName)
		{
		}

		public void SetScopedCertificate(StoreLocation storeLocation, StoreName storeName, X509FindType findType, object findValue, Uri targetService)
		{
		}

		public void SetScopedCertificate(string subjectName, StoreLocation storeLocation, StoreName storeName, Uri targetService)
		{
		}
	}
	public enum X509CertificateValidationMode
	{
		ChainTrust = 2,
		Custom = 4,
		None = 0,
		PeerOrChainTrust = 3,
		PeerTrust = 1
	}
	internal interface ISecurityCommunicationObject
	{
		TimeSpan DefaultOpenTimeout { get; }

		TimeSpan DefaultCloseTimeout { get; }

		void OnAbort();

		Task OnCloseAsync(TimeSpan timeout);

		void OnClosed();

		void OnClosing();

		void OnFaulted();

		Task OnOpenAsync(TimeSpan timeout);

		void OnOpened();

		void OnOpening();
	}
	public enum SecurityKeyEntropyMode
	{
		ClientEntropy,
		ServerEntropy,
		CombinedEntropy
	}
	public abstract class BasicSecurityProfileVersion
	{
		public static BasicSecurityProfileVersion BasicSecurityProfile10 => null;

		internal BasicSecurityProfileVersion()
		{
		}
	}
	public abstract class IdentityVerifier
	{
		public static IdentityVerifier CreateDefault()
		{
			return null;
		}

		public abstract bool CheckAccess(EndpointIdentity identity, AuthorizationContext authContext);

		public abstract bool TryGetIdentity(EndpointAddress reference, out EndpointIdentity identity);
	}
	public class SecurityMessageProperty : IMessageProperty, IDisposable
	{
		public ServiceSecurityContext ServiceSecurityContext { get; set; }

		public ReadOnlyCollection<IAuthorizationPolicy> ExternalAuthorizationPolicies { get; set; }

		public SecurityTokenSpecification ProtectionToken { get; set; }

		public SecurityTokenSpecification InitiatorToken { get; set; }

		public SecurityTokenSpecification RecipientToken { get; set; }

		public SecurityTokenSpecification TransportToken { get; set; }

		public string SenderIdPrefix { get; set; }

		public bool HasIncomingSupportingTokens => false;

		public Collection<SupportingTokenSpecification> IncomingSupportingTokens => null;

		public Collection<SupportingTokenSpecification> OutgoingSupportingTokens => null;

		internal bool HasOutgoingSupportingTokens => false;

		public IMessageProperty CreateCopy()
		{
			return null;
		}

		public static SecurityMessageProperty GetOrCreate(Message message)
		{
			return null;
		}

		public void Dispose()
		{
		}
	}
	public abstract class SecureConversationVersion
	{
		public static SecureConversationVersion Default => null;

		public XmlDictionaryString Namespace => null;

		public XmlDictionaryString Prefix => null;

		public static SecureConversationVersion WSSecureConversationFeb2005 => null;

		public static SecureConversationVersion WSSecureConversation13 => null;

		internal SecureConversationVersion()
		{
		}
	}
	public abstract class SecurityAlgorithmSuite
	{
		public static SecurityAlgorithmSuite TripleDes => null;

		public abstract string DefaultCanonicalizationAlgorithm { get; }

		public abstract string DefaultDigestAlgorithm { get; }

		public abstract string DefaultEncryptionAlgorithm { get; }

		public abstract int DefaultEncryptionKeyDerivationLength { get; }

		public abstract string DefaultSymmetricKeyWrapAlgorithm { get; }

		public abstract string DefaultAsymmetricKeyWrapAlgorithm { get; }

		public abstract string DefaultSymmetricSignatureAlgorithm { get; }

		public abstract string DefaultAsymmetricSignatureAlgorithm { get; }

		public abstract int DefaultSignatureKeyDerivationLength { get; }

		public abstract int DefaultSymmetricKeyLength { get; }

		public static SecurityAlgorithmSuite Default { get; }

		public static SecurityAlgorithmSuite Basic256 { get; }

		public static SecurityAlgorithmSuite Basic256Sha256 { get; }

		public abstract bool IsSymmetricKeyLengthSupported(int length);

		public abstract bool IsAsymmetricKeyLengthSupported(int length);
	}
	public enum SecurityTokenAttachmentMode
	{
		Signed,
		Endorsing,
		SignedEndorsing,
		SignedEncrypted
	}
	public class SecurityTokenSpecification
	{
		public SecurityToken SecurityToken => null;

		public ReadOnlyCollection<IAuthorizationPolicy> SecurityTokenPolicies => null;

		public SecurityTokenSpecification(SecurityToken token, ReadOnlyCollection<IAuthorizationPolicy> tokenPolicies)
		{
		}
	}
	public abstract class SecurityPolicyVersion
	{
		public string Namespace => null;

		public string Prefix => null;

		public static SecurityPolicyVersion WSSecurityPolicy11 => null;

		public static SecurityPolicyVersion WSSecurityPolicy12 => null;

		internal SecurityPolicyVersion()
		{
		}
	}
	public abstract class SecurityVersion
	{
		public static SecurityVersion WSSecurity10 => null;

		public static SecurityVersion WSSecurity11 => null;

		internal SecurityVersion()
		{
		}
	}
	public class SupportingTokenSpecification : SecurityTokenSpecification
	{
		public SecurityTokenAttachmentMode SecurityTokenAttachmentMode => SecurityTokenAttachmentMode.Signed;

		public SupportingTokenSpecification(SecurityToken token, ReadOnlyCollection<IAuthorizationPolicy> tokenPolicies, SecurityTokenAttachmentMode attachmentMode)
			: base(null, null)
		{
		}

		public SupportingTokenSpecification(SecurityToken token, ReadOnlyCollection<IAuthorizationPolicy> tokenPolicies, SecurityTokenAttachmentMode attachmentMode, SecurityTokenParameters tokenParameters)
			: base(null, null)
		{
		}
	}
	public abstract class TrustVersion
	{
		public static TrustVersion Default => null;

		public XmlDictionaryString Namespace => null;

		public XmlDictionaryString Prefix => null;

		public static TrustVersion WSTrustFeb2005 => null;

		public static TrustVersion WSTrust13 => null;

		internal TrustVersion()
		{
		}
	}
}
namespace System.ServiceModel.Security.Tokens
{
	public class BinarySecretSecurityToken : SecurityToken
	{
		public override string Id => null;

		public override DateTime ValidFrom => default(DateTime);

		public override DateTime ValidTo => default(DateTime);

		public int KeySize => 0;

		public override ReadOnlyCollection<SecurityKey> SecurityKeys => null;

		public BinarySecretSecurityToken(string id, byte[] key)
		{
		}

		public BinarySecretSecurityToken(byte[] key)
		{
		}

		protected BinarySecretSecurityToken(string id, int keySizeInBits, bool allowCrypto)
		{
		}

		protected BinarySecretSecurityToken(string id, byte[] key, bool allowCrypto)
		{
		}

		public byte[] GetKeyBytes()
		{
			return null;
		}
	}
	public sealed class InitiatorServiceModelSecurityTokenRequirement : ServiceModelSecurityTokenRequirement
	{
		public EndpointAddress TargetAddress
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public Uri Via
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public override string ToString()
		{
			return null;
		}
	}
	public class IssuedSecurityTokenParameters : SecurityTokenParameters
	{
		public Collection<XmlElement> AdditionalRequestParameters => null;

		public MessageSecurityVersion DefaultMessageSecurityVersion
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public EndpointAddress IssuerAddress
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public Binding IssuerBinding
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public SecurityKeyType KeyType
		{
			get
			{
				return SecurityKeyType.SymmetricKey;
			}
			set
			{
			}
		}

		public int KeySize
		{
			get
			{
				return 0;
			}
			set
			{
			}
		}

		public string TokenType
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		protected IssuedSecurityTokenParameters(IssuedSecurityTokenParameters other)
		{
		}

		public IssuedSecurityTokenParameters()
		{
		}

		protected override SecurityTokenParameters CloneCore()
		{
			return null;
		}
	}
	public class SecureConversationSecurityTokenParameters : SecurityTokenParameters
	{
		public SecurityBindingElement BootstrapSecurityBindingElement
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public bool RequireCancellation
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public SecureConversationSecurityTokenParameters()
		{
		}

		public SecureConversationSecurityTokenParameters(SecurityBindingElement bootstrapSecurityBindingElement)
		{
		}

		protected override SecurityTokenParameters CloneCore()
		{
			return null;
		}
	}
	public abstract class SecurityTokenParameters
	{
		public bool RequireDerivedKeys
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		internal SecurityTokenParameters()
		{
		}

		protected abstract SecurityTokenParameters CloneCore();

		public SecurityTokenParameters Clone()
		{
			return null;
		}
	}
	public abstract class ServiceModelSecurityTokenRequirement : SecurityTokenRequirement
	{
		public bool IsInitiator => false;

		public SecurityAlgorithmSuite SecurityAlgorithmSuite
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public SecurityBindingElement SecurityBindingElement
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public EndpointAddress IssuerAddress
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public Binding IssuerBinding
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public SecurityBindingElement SecureConversationSecurityBindingElement
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public SecurityTokenVersion MessageSecurityVersion
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string TransportScheme
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public static string ChannelParametersCollectionProperty => null;
	}
	public class SspiSecurityToken : SecurityToken
	{
		public override string Id => null;

		public override DateTime ValidFrom => default(DateTime);

		public override DateTime ValidTo => default(DateTime);

		public bool AllowUnauthenticatedCallers => false;

		public TokenImpersonationLevel ImpersonationLevel => TokenImpersonationLevel.None;

		public bool AllowNtlm => false;

		public NetworkCredential NetworkCredential => null;

		public bool ExtractGroupsForWindowsAccounts => false;

		public override ReadOnlyCollection<SecurityKey> SecurityKeys => null;

		public SspiSecurityToken(TokenImpersonationLevel impersonationLevel, bool allowNtlm, NetworkCredential networkCredential)
		{
		}

		public SspiSecurityToken(NetworkCredential networkCredential, bool extractGroupsForWindowsAccounts, bool allowUnauthenticatedCallers)
		{
		}
	}
	public class SupportingTokenParameters
	{
		public Collection<SecurityTokenParameters> Endorsing => null;

		public Collection<SecurityTokenParameters> SignedEncrypted => null;

		public Collection<SecurityTokenParameters> Signed => null;

		public SupportingTokenParameters Clone()
		{
			return null;
		}
	}
	public class UserNameSecurityTokenParameters : SecurityTokenParameters
	{
		protected override SecurityTokenParameters CloneCore()
		{
			return null;
		}
	}
}
namespace System.ServiceModel.Dispatcher
{
	public sealed class ClientOperation
	{
		public string Action => null;

		public SynchronizedCollection<FaultContractInfo> FaultContractInfos => null;

		public ICollection<IParameterInspector> ClientParameterInspectors => null;

		public bool DeserializeReply
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public IClientMessageFormatter Formatter
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public bool IsOneWay
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public string Name => null;

		public ClientRuntime Parent => null;

		public string ReplyAction => null;

		public bool SerializeRequest
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public MethodInfo TaskMethod
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public Type TaskTResult
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MethodInfo BeginMethod
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MethodInfo EndMethod
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MethodInfo SyncMethod
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public ClientOperation(ClientRuntime parent, string name, string action)
		{
		}

		public ClientOperation(ClientRuntime parent, string name, string action, string replyAction)
		{
		}
	}
	public sealed class ClientRuntime
	{
		public SynchronizedCollection<IChannelInitializer> ChannelInitializers => null;

		public ICollection<IClientMessageInspector> ClientMessageInspectors => null;

		public DispatchRuntime CallbackDispatchRuntime => null;

		public ICollection<ClientOperation> ClientOperations => null;

		public Type ContractClientType
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string ContractName => null;

		public string ContractNamespace => null;

		public SynchronizedCollection<IInteractiveChannelInitializer> InteractiveChannelInitializers => null;

		public bool ManualAddressing
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public int MaxFaultSize
		{
			get
			{
				return 0;
			}
			set
			{
			}
		}

		public IClientOperationSelector OperationSelector
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public ClientOperation UnhandledClientOperation => null;

		public Uri Via
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		internal ClientRuntime()
		{
		}
	}
	public sealed class DispatchOperation
	{
		public string Action => null;

		public bool AutoDisposeParameters
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public bool DeserializeRequest
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public bool IsOneWay => false;

		public string Name => null;

		public DispatchRuntime Parent => null;

		public bool SerializeReply
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public DispatchOperation(DispatchRuntime parent, string name, string action)
		{
		}
	}
	public sealed class DispatchRuntime
	{
		public SynchronizedCollection<IDispatchMessageInspector> MessageInspectors => null;

		public ChannelDispatcher ChannelDispatcher => null;

		internal DispatchRuntime()
		{
		}
	}
	public class ChannelDispatcher
	{
		public bool IncludeExceptionDetailInFaults
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		internal ChannelDispatcher()
		{
		}
	}
	public class EndpointDispatcher
	{
		internal EndpointDispatcher()
		{
		}
	}
	public class FaultContractInfo
	{
		public string Action => null;

		public Type Detail => null;

		public FaultContractInfo(string action, Type detail)
		{
		}
	}
	public interface IChannelInitializer
	{
		void Initialize(IClientChannel channel);
	}
	public interface IClientMessageFormatter
	{
		object DeserializeReply(Message message, object[] parameters);

		Message SerializeRequest(MessageVersion messageVersion, object[] parameters);
	}
	public interface IClientMessageInspector
	{
		void AfterReceiveReply(ref Message reply, object correlationState);

		object BeforeSendRequest(ref Message request, IClientChannel channel);
	}
	public interface IDispatchMessageInspector
	{
		object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext);

		void BeforeSendReply(ref Message reply, object correlationState);
	}
	public interface IClientOperationSelector
	{
		bool AreParametersRequiredForSelection { get; }

		string SelectOperation(MethodBase method, object[] parameters);
	}
	public interface IInteractiveChannelInitializer
	{
		IAsyncResult BeginDisplayInitializationUI(IClientChannel channel, AsyncCallback callback, object state);

		void EndDisplayInitializationUI(IAsyncResult result);
	}
	public interface IParameterInspector
	{
		void AfterCall(string operationName, object[] outputs, object returnValue, object correlationState);

		object BeforeCall(string operationName, object[] inputs);
	}
}
namespace System.ServiceModel.Description
{
	public class CallbackDebugBehavior : IEndpointBehavior
	{
		public bool IncludeExceptionDetailInFaults
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public CallbackDebugBehavior(bool includeExceptionDetailInFaults)
		{
		}

		void IEndpointBehavior.ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime behavior)
		{
		}

		void IEndpointBehavior.AddBindingParameters(ServiceEndpoint serviceEndpoint, BindingParameterCollection bindingParameters)
		{
		}

		void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint serviceEndpoint, EndpointDispatcher endpointDispatcher)
		{
		}

		void IEndpointBehavior.Validate(ServiceEndpoint serviceEndpoint)
		{
		}
	}
	public class ClientCredentials : SecurityCredentialsManager, IEndpointBehavior
	{
		public X509CertificateInitiatorClientCredential ClientCertificate => null;

		public HttpDigestClientCredential HttpDigest => null;

		public X509CertificateRecipientClientCredential ServiceCertificate => null;

		public UserNamePasswordClientCredential UserName => null;

		public WindowsClientCredential Windows => null;

		public ClientCredentials()
		{
		}

		protected ClientCredentials(ClientCredentials other)
		{
		}

		public override SecurityTokenManager CreateSecurityTokenManager()
		{
			return null;
		}

		public virtual void ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime behavior)
		{
		}

		public ClientCredentials Clone()
		{
			return null;
		}

		protected virtual ClientCredentials CloneCore()
		{
			return null;
		}

		void IEndpointBehavior.AddBindingParameters(ServiceEndpoint serviceEndpoint, BindingParameterCollection bindingParameters)
		{
		}

		void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint serviceEndpoint, EndpointDispatcher endpointDispatcher)
		{
		}

		void IEndpointBehavior.Validate(ServiceEndpoint serviceEndpoint)
		{
		}
	}
	public class ContractDescription
	{
		public Type CallbackContractType
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DefaultValue(null)]
		public string ConfigurationName
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public KeyedCollection<Type, IContractBehavior> ContractBehaviors => null;

		public Type ContractType
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Namespace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public OperationDescriptionCollection Operations => null;

		public ContractDescription(string name)
		{
		}

		public ContractDescription(string name, string ns)
		{
		}

		public static ContractDescription GetContract(Type contractType)
		{
			return null;
		}
	}
	public class DataContractSerializerOperationBehavior : IOperationBehavior
	{
		public DataContractFormatAttribute DataContractFormatAttribute => null;

		public DataContractResolver DataContractResolver
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public int MaxItemsInObjectGraph
		{
			get
			{
				return 0;
			}
			set
			{
			}
		}

		public DataContractSerializerOperationBehavior(OperationDescription operation)
		{
		}

		public DataContractSerializerOperationBehavior(OperationDescription operation, DataContractFormatAttribute dataContractFormatAttribute)
		{
		}

		public virtual XmlObjectSerializer CreateSerializer(Type type, string name, string ns, IList<Type> knownTypes)
		{
			return null;
		}

		public virtual XmlObjectSerializer CreateSerializer(Type type, XmlDictionaryString name, XmlDictionaryString ns, IList<Type> knownTypes)
		{
			return null;
		}

		void IOperationBehavior.AddBindingParameters(OperationDescription description, BindingParameterCollection parameters)
		{
		}

		void IOperationBehavior.ApplyClientBehavior(OperationDescription description, ClientOperation proxy)
		{
		}

		void IOperationBehavior.ApplyDispatchBehavior(OperationDescription description, DispatchOperation dispatch)
		{
		}

		void IOperationBehavior.Validate(OperationDescription description)
		{
		}
	}
	public class FaultDescription
	{
		public string Action => null;

		public Type DetailType
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Namespace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public FaultDescription(string action)
		{
		}
	}
	public class FaultDescriptionCollection : Collection<FaultDescription>
	{
		internal FaultDescriptionCollection()
		{
		}
	}
	public interface IContractBehavior
	{
		void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters);

		void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, ClientRuntime clientRuntime);

		void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime);

		void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint);
	}
	public interface IEndpointBehavior
	{
		void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters);

		void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime);

		void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher);

		void Validate(ServiceEndpoint endpoint);
	}
	public interface IOperationBehavior
	{
		void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters);

		void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation);

		void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation);

		void Validate(OperationDescription operationDescription);
	}
	public class MessageBodyDescription
	{
		public MessagePartDescriptionCollection Parts => null;

		[DefaultValue(null)]
		public MessagePartDescription ReturnValue
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DefaultValue(null)]
		public string WrapperName
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DefaultValue(null)]
		public string WrapperNamespace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}
	}
	public class MessageDescription
	{
		public string Action => null;

		public MessageBodyDescription Body => null;

		public MessageDirection Direction => MessageDirection.Input;

		public MessageHeaderDescriptionCollection Headers => null;

		[DefaultValue(null)]
		public Type MessageType
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MessagePropertyDescriptionCollection Properties => null;

		public MessageDescription(string action, MessageDirection direction)
		{
		}
	}
	public class MessageDescriptionCollection : Collection<MessageDescription>
	{
		internal MessageDescriptionCollection()
		{
		}

		public MessageDescription Find(string action)
		{
			return null;
		}

		public Collection<MessageDescription> FindAll(string action)
		{
			return null;
		}
	}
	public enum MessageDirection
	{
		Input,
		Output
	}
	public class MessageHeaderDescription : MessagePartDescription
	{
		[DefaultValue(null)]
		public string Actor
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DefaultValue(false)]
		public bool MustUnderstand
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		[DefaultValue(false)]
		public bool Relay
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		[DefaultValue(false)]
		public bool TypedHeader
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public MessageHeaderDescription(string name, string ns)
			: base(null, null)
		{
		}
	}
	public class MessageHeaderDescriptionCollection : KeyedCollection<XmlQualifiedName, MessageHeaderDescription>
	{
		internal MessageHeaderDescriptionCollection()
		{
		}

		protected override XmlQualifiedName GetKeyForItem(MessageHeaderDescription item)
		{
			return null;
		}
	}
	public class MessagePartDescription
	{
		public int Index
		{
			get
			{
				return 0;
			}
			set
			{
			}
		}

		public MemberInfo MemberInfo
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DefaultValue(false)]
		public bool Multiple
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public string Name => null;

		public string Namespace => null;

		public Type Type
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MessagePartDescription(string name, string ns)
		{
		}
	}
	public class MessagePartDescriptionCollection : KeyedCollection<XmlQualifiedName, MessagePartDescription>
	{
		internal MessagePartDescriptionCollection()
		{
		}

		protected override XmlQualifiedName GetKeyForItem(MessagePartDescription item)
		{
			return null;
		}
	}
	public class MessagePropertyDescription : MessagePartDescription
	{
		public MessagePropertyDescription(string name)
			: base(null, null)
		{
		}
	}
	public class MessagePropertyDescriptionCollection : KeyedCollection<string, MessagePropertyDescription>
	{
		internal MessagePropertyDescriptionCollection()
		{
		}

		protected override string GetKeyForItem(MessagePropertyDescription item)
		{
			return null;
		}
	}
	public class OperationDescription
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public KeyedByTypeCollection<IOperationBehavior> Behaviors => null;

		public ContractDescription DeclaringContract
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public FaultDescriptionCollection Faults => null;

		public bool IsOneWay => false;

		public Collection<Type> KnownTypes => null;

		public MessageDescriptionCollection Messages => null;

		public string Name => null;

		public KeyedCollection<Type, IOperationBehavior> OperationBehaviors => null;

		public MethodInfo TaskMethod
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MethodInfo BeginMethod
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MethodInfo EndMethod
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MethodInfo SyncMethod
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public OperationDescription(string name, ContractDescription declaringContract)
		{
		}
	}
	public class OperationDescriptionCollection : Collection<OperationDescription>
	{
		internal OperationDescriptionCollection()
		{
		}

		public OperationDescription Find(string name)
		{
			return null;
		}

		public Collection<OperationDescription> FindAll(string name)
		{
			return null;
		}

		protected override void InsertItem(int index, OperationDescription item)
		{
		}

		protected override void SetItem(int index, OperationDescription item)
		{
		}
	}
	public class ServiceEndpoint
	{
		public EndpointAddress Address
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public Binding Binding
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public ContractDescription Contract
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public KeyedCollection<Type, IEndpointBehavior> EndpointBehaviors => null;

		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public ServiceEndpoint(ContractDescription contract)
		{
		}

		public ServiceEndpoint(ContractDescription contract, Binding binding, EndpointAddress address)
		{
		}
	}
	public class XmlSerializerOperationBehavior : IOperationBehavior
	{
		public XmlSerializerFormatAttribute XmlSerializerFormatAttribute => null;

		public XmlSerializerOperationBehavior(OperationDescription operation)
		{
		}

		public XmlSerializerOperationBehavior(OperationDescription operation, XmlSerializerFormatAttribute attribute)
		{
		}

		public Collection<XmlMapping> GetXmlMappings()
		{
			throw null;
		}

		void IOperationBehavior.Validate(OperationDescription description)
		{
		}

		void IOperationBehavior.AddBindingParameters(OperationDescription description, BindingParameterCollection parameters)
		{
		}

		void IOperationBehavior.ApplyDispatchBehavior(OperationDescription description, DispatchOperation dispatch)
		{
		}

		void IOperationBehavior.ApplyClientBehavior(OperationDescription description, ClientOperation proxy)
		{
		}
	}
	public abstract class TypedMessageConverter
	{
		public static TypedMessageConverter Create(Type messageContract, string action)
		{
			return null;
		}

		public static TypedMessageConverter Create(Type messageContract, string action, string defaultNamespace)
		{
			return null;
		}

		public static TypedMessageConverter Create(Type messageContract, string action, XmlSerializerFormatAttribute formatterAttribute)
		{
			return null;
		}

		public static TypedMessageConverter Create(Type messageContract, string action, DataContractFormatAttribute formatterAttribute)
		{
			return null;
		}

		public static TypedMessageConverter Create(Type messageContract, string action, string defaultNamespace, XmlSerializerFormatAttribute formatterAttribute)
		{
			return null;
		}

		public static TypedMessageConverter Create(Type messageContract, string action, string defaultNamespace, DataContractFormatAttribute formatterAttribute)
		{
			return null;
		}

		public abstract Message ToMessage(object typedMessage);

		public abstract Message ToMessage(object typedMessage, MessageVersion version);

		public abstract object FromMessage(Message message);
	}
}
namespace System.ServiceModel.Channels
{
	public abstract class AddressHeader
	{
		public abstract string Name { get; }

		public abstract string Namespace { get; }

		public static AddressHeader CreateAddressHeader(string name, string ns, object value)
		{
			return null;
		}

		public static AddressHeader CreateAddressHeader(string name, string ns, object value, XmlObjectSerializer serializer)
		{
			return null;
		}

		public override bool Equals(object obj)
		{
			return false;
		}

		public virtual XmlDictionaryReader GetAddressHeaderReader()
		{
			return null;
		}

		public override int GetHashCode()
		{
			return 0;
		}

		public T GetValue<T>()
		{
			return default(T);
		}

		public T GetValue<T>(XmlObjectSerializer serializer)
		{
			return default(T);
		}

		protected abstract void OnWriteAddressHeaderContents(XmlDictionaryWriter writer);

		protected virtual void OnWriteStartAddressHeader(XmlDictionaryWriter writer)
		{
		}

		public MessageHeader ToMessageHeader()
		{
			return null;
		}

		public void WriteAddressHeader(XmlDictionaryWriter writer)
		{
		}

		public void WriteAddressHeader(XmlWriter writer)
		{
		}

		public void WriteAddressHeaderContents(XmlDictionaryWriter writer)
		{
		}

		public void WriteStartAddressHeader(XmlDictionaryWriter writer)
		{
		}
	}
	public sealed class AddressHeaderCollection : ReadOnlyCollection<AddressHeader>
	{
		public AddressHeaderCollection()
			: base((IList<AddressHeader>)null)
		{
		}

		public AddressHeaderCollection(IEnumerable<AddressHeader> addressHeaders)
			: base((IList<AddressHeader>)null)
		{
		}

		public void AddHeadersTo(Message message)
		{
		}

		public AddressHeader[] FindAll(string name, string ns)
		{
			return null;
		}

		public AddressHeader FindHeader(string name, string ns)
		{
			return null;
		}
	}
	public sealed class AddressingVersion
	{
		public static AddressingVersion None => null;

		public static AddressingVersion WSAddressing10 => null;

		public static AddressingVersion WSAddressingAugust2004 => null;

		internal AddressingVersion()
		{
		}

		public override string ToString()
		{
			return null;
		}
	}
	public sealed class BinaryMessageEncodingBindingElement : MessageEncodingBindingElement
	{
		[DefaultValue(CompressionFormat.None)]
		public CompressionFormat CompressionFormat
		{
			get
			{
				return CompressionFormat.None;
			}
			set
			{
			}
		}

		[DefaultValue(2048)]
		public int MaxSessionSize
		{
			get
			{
				return 0;
			}
			set
			{
			}
		}

		public int MaxReadPoolSize
		{
			get
			{
				return 0;
			}
			set
			{
			}
		}

		public int MaxWritePoolSize
		{
			get
			{
				return 0;
			}
			set
			{
			}
		}

		public override MessageVersion MessageVersion
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public XmlDictionaryReaderQuotas ReaderQuotas
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
		{
			return null;
		}

		public override BindingElement Clone()
		{
			return null;
		}

		public override MessageEncoderFactory CreateMessageEncoderFactory()
		{
			return null;
		}

		public override T GetProperty<T>(BindingContext context)
		{
			return null;
		}
	}
	public abstract class Binding : IDefaultCommunicationTimeouts
	{
		[DefaultValue(typeof(TimeSpan), "00:01:00")]
		public TimeSpan CloseTimeout
		{
			get
			{
				return default(TimeSpan);
			}
			set
			{
			}
		}

		public MessageVersion MessageVersion => null;

		public string Name
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public string Namespace
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		[DefaultValue(typeof(TimeSpan), "00:01:00")]
		public TimeSpan OpenTimeout
		{
			get
			{
				return default(TimeSpan);
			}
			set
			{
			}
		}

		[DefaultValue(typeof(TimeSpan), "00:10:00")]
		public TimeSpan ReceiveTimeout
		{
			get
			{
				return default(TimeSpan);
			}
			set
			{
			}
		}

		public abstract string Scheme { get; }

		[DefaultValue(typeof(TimeSpan), "00:01:00")]
		public TimeSpan SendTimeout
		{
			get
			{
				return default(TimeSpan);
			}
			set
			{
			}
		}

		protected Binding()
		{
		}

		protected Binding(string name, string ns)
		{
		}

		public IChannelFactory<TChannel> BuildChannelFactory<TChannel>(params object[] parameters)
		{
			return null;
		}

		public virtual IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingParameterCollection parameters)
		{
			return null;
		}

		public bool CanBuildChannelFactory<TChannel>(params object[] parameters)
		{
			return false;
		}

		public virtual bool CanBuildChannelFactory<TChannel>(BindingParameterCollection parameters)
		{
			return false;
		}

		public abstract BindingElementCollection CreateBindingElements();

		public T GetProperty<T>(BindingParameterCollection parameters) where T : class
		{
			return null;
		}
	}
	public class BindingContext
	{
		public CustomBinding Binding => null;

		public BindingParameterCollection BindingParameters => null;

		public BindingElementCollection RemainingBindingElements => null;

		public BindingContext(CustomBinding binding, BindingParameterCollection parameters)
		{
		}

		public IChannelFactory<TChannel> BuildInnerChannelFactory<TChannel>()
		{
			return null;
		}

		public bool CanBuildInnerChannelFactory<TChannel>()
		{
			return false;
		}

		public BindingContext Clone()
		{
			return null;
		}

		public T GetInnerProperty<T>() where T : class
		{
			return null;
		}
	}
	public abstract class BindingElement
	{
		protected BindingElement()
		{
		}

		protected BindingElement(BindingElement elementToBeCloned)
		{
		}

		public virtual IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
		{
			return null;
		}

		public virtual bool CanBuildChannelFactory<TChannel>(BindingContext context)
		{
			return false;
		}

		public abstract BindingElement Clone();

		public abstract T GetProperty<T>(BindingContext context) where T : class;
	}
	public class BindingElementCollection : Collection<BindingElement>
	{
		public BindingElementCollection()
		{
		}

		public BindingElementCollection(IEnumerable<BindingElement> elements)
		{
		}

		public BindingElementCollection(BindingElement[] elements)
		{
		}

		public void AddRange(params BindingElement[] elements)
		{
		}

		public BindingElementCollection Clone()
		{
			return null;
		}

		public bool Contains(Type bindingElementType)
		{
			return false;
		}

		public T Find<T>()
		{
			return default(T);
		}

		public Collection<T> FindAll<T>()
		{
			return null;
		}

		protected override void InsertItem(int index, BindingElement item)
		{
		}

		public T Remove<T>()
		{
			return default(T);
		}

		public Collection<T> RemoveAll<T>()
		{
			return null;
		}

		protected override void SetItem(int index, BindingElement item)
		{
		}
	}
	public class BindingParameterCollection : KeyedByTypeCollection<object>
	{
	}
	public abstract class BodyWriter
	{
		public bool IsBuffered => false;

		protected BodyWriter(bool isBuffered)
		{
		}

		public BodyWriter CreateBufferedCopy(int maxBufferSize)
		{
			return null;
		}

		protected virtual BodyWriter OnCreateBufferedCopy(int maxBufferSize)
		{
			return null;
		}

		protected abstract void OnWriteBodyContents(XmlDictionaryWriter writer);

		public void WriteBodyContents(XmlDictionaryWriter writer)
		{
		}
	}
	public abstract class BufferManager
	{
		public abstract void Clear();

		public static BufferManager CreateBufferManager(long maxBufferPoolSize, int maxBufferSize)
		{
			return null;
		}

		public abstract void ReturnBuffer(byte[] buffer);

		public abstract byte[] TakeBuffer(int bufferSize);
	}
	public abstract class ChannelBase : CommunicationObject, IChannel, ICommunicationObject, IDefaultCommunicationTimeouts
	{
		protected override TimeSpan DefaultCloseTimeout => default(TimeSpan);

		protected override TimeSpan DefaultOpenTimeout => default(TimeSpan);

		protected TimeSpan DefaultReceiveTimeout => default(TimeSpan);

		protected TimeSpan DefaultSendTimeout => default(TimeSpan);

		protected ChannelManagerBase Manager => null;

		TimeSpan IDefaultCommunicationTimeouts.CloseTimeout => default(TimeSpan);

		TimeSpan IDefaultCommunicationTimeouts.OpenTimeout => default(TimeSpan);

		TimeSpan IDefaultCommunicationTimeouts.ReceiveTimeout => default(TimeSpan);

		TimeSpan IDefaultCommunicationTimeouts.SendTimeout => default(TimeSpan);

		protected ChannelBase(ChannelManagerBase channelManager)
		{
		}

		public virtual T GetProperty<T>() where T : class
		{
			return null;
		}

		protected override void OnClosed()
		{
		}
	}
	public abstract class ChannelFactoryBase : ChannelManagerBase, IChannelFactory, ICommunicationObject
	{
		protected override TimeSpan DefaultCloseTimeout => default(TimeSpan);

		protected override TimeSpan DefaultOpenTimeout => default(TimeSpan);

		protected override TimeSpan DefaultReceiveTimeout => default(TimeSpan);

		protected override TimeSpan DefaultSendTimeout => default(TimeSpan);

		protected ChannelFactoryBase()
		{
		}

		protected ChannelFactoryBase(IDefaultCommunicationTimeouts timeouts)
		{
		}

		public virtual T GetProperty<T>() where T : class
		{
			return null;
		}

		protected override void OnAbort()
		{
		}

		protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		protected override void OnClose(TimeSpan timeout)
		{
		}

		protected override void OnEndClose(IAsyncResult result)
		{
		}
	}
	public abstract class ChannelFactoryBase<TChannel> : ChannelFactoryBase, IChannelFactory, ICommunicationObject, IChannelFactory<TChannel>
	{
		protected ChannelFactoryBase()
		{
		}

		protected ChannelFactoryBase(IDefaultCommunicationTimeouts timeouts)
		{
		}

		public TChannel CreateChannel(EndpointAddress address)
		{
			return default(TChannel);
		}

		public TChannel CreateChannel(EndpointAddress address, Uri via)
		{
			return default(TChannel);
		}

		protected override void OnAbort()
		{
		}

		protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		protected override void OnClose(TimeSpan timeout)
		{
		}

		protected abstract TChannel OnCreateChannel(EndpointAddress address, Uri via);

		protected override void OnEndClose(IAsyncResult result)
		{
		}

		protected void ValidateCreateChannel()
		{
		}
	}
	public abstract class ChannelManagerBase : CommunicationObject, IDefaultCommunicationTimeouts
	{
		protected abstract TimeSpan DefaultReceiveTimeout { get; }

		protected abstract TimeSpan DefaultSendTimeout { get; }

		TimeSpan IDefaultCommunicationTimeouts.CloseTimeout => default(TimeSpan);

		TimeSpan IDefaultCommunicationTimeouts.OpenTimeout => default(TimeSpan);

		TimeSpan IDefaultCommunicationTimeouts.ReceiveTimeout => default(TimeSpan);

		TimeSpan IDefaultCommunicationTimeouts.SendTimeout => default(TimeSpan);
	}
	public class ChannelParameterCollection : Collection<object>
	{
		protected virtual IChannel Channel => null;

		public ChannelParameterCollection()
		{
		}

		public ChannelParameterCollection(IChannel channel)
		{
		}

		protected override void ClearItems()
		{
		}

		protected override void InsertItem(int index, object item)
		{
		}

		public void PropagateChannelParameters(IChannel innerChannel)
		{
		}

		protected override void RemoveItem(int index)
		{
		}

		protected override void SetItem(int index, object item)
		{
		}
	}
	public abstract class CommunicationObject : ICommunicationObject
	{
		protected abstract TimeSpan DefaultCloseTimeout { get; }

		protected abstract TimeSpan DefaultOpenTimeout { get; }

		protected bool IsDisposed => false;

		public CommunicationState State => CommunicationState.Created;

		protected object ThisLock => null;

		public event EventHandler Closed
		{
			add
			{
			}
			remove
			{
			}
		}

		public event EventHandler Closing
		{
			add
			{
			}
			remove
			{
			}
		}

		public event EventHandler Faulted
		{
			add
			{
			}
			remove
			{
			}
		}

		public event EventHandler Opened
		{
			add
			{
			}
			remove
			{
			}
		}

		public event EventHandler Opening
		{
			add
			{
			}
			remove
			{
			}
		}

		protected CommunicationObject()
		{
		}

		protected CommunicationObject(object mutex)
		{
		}

		public void Abort()
		{
		}

		public IAsyncResult BeginClose(AsyncCallback callback, object state)
		{
			return null;
		}

		public IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		public IAsyncResult BeginOpen(AsyncCallback callback, object state)
		{
			return null;
		}

		public IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
		{
			return null;
		}

		public void Close()
		{
		}

		public void Close(TimeSpan timeout)
		{
		}

		public void EndClose(IAsyncResult result)
		{
		}

		public void EndOpen(IAsyncResult result)
		{
		}

		protected void Fault()
		{
		}

		protected virtual Type GetCommunicationObjectType()
		{
			return null;
		}

		protected abstract void OnAbort();

		protected abstract IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state);

		protected abstract IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state);

		protected abstract void OnClose(TimeSpan timeout);

		protected virtual void OnClosed()
		{
		}

		protected virtual void OnClosing()
		{
		}

		protected abstract void OnEndClose(IAsyncResult result);

		protected abstract void OnEndOpen(IAsyncResult result);

		protected virtual void OnFaulted()
		{
		}

		protected abstract void OnOpen(TimeSpan timeout);

		protected virtual void OnOpened()
		{
		}

		protected virtual void OnOpening()
		{
		}

		public void Open()
		{
		}

		public void Open(TimeSpan timeout)
		{
		}
	}
	public enum CompressionFormat
	{
		Deflate = 2,
		GZip = 1,
		None = 0
	}
	public class CustomBinding : Binding
	{
		public BindingElementCollection Elements => null;

		public override string Scheme => null;

		public CustomBinding()
		{
		}

		public CustomBinding(IEnumerable<BindingElement> bindingElementsInTopDownChannelStackOrder)
		{
		}

		public CustomBinding(Binding binding)
		{
		}

		public CustomBinding(params BindingElement[] bindingElementsInTopDownChannelStackOrder)
		{
		}

		public CustomBinding(string name, string ns, params BindingElement[] bindingElementsInTopDownChannelStackOrder)
		{
		}

		public override BindingElementCollection CreateBindingElements()
		{
			return null;
		}
	}
	public abstract class FaultConverter
	{
		public static FaultConverter GetDefaultFaultConverter(MessageVersion version)
		{
			return null;
		}

		protected abstract bool OnTryCreateException(Message message, MessageFault fault, out Exception exception);

		protected abstract bool OnTryCreateFaultMessage(Exception exception, out Message message);

		public bool TryCreateException(Message message, MessageFault fault, out Exception exception)
		{
			exception = null;
			return false;
		}
	}
	public interface IChannel : ICommunicationObject
	{
		T GetProperty<T>() where T : class;
	}
	public interface IChannelFactory : ICommunicationObject
	{
		T GetProperty<T>() where T : class;
	}
	public interface IChannelFactory<TChannel> : IChannelFactory, ICommunicationObject
	{
		TChannel CreateChannel(EndpointAddress to);

		TChannel CreateChannel(EndpointAddress to, Uri via);
	}
	public interface IBindingDeliveryCapabilities
	{
		bool AssuresOrderedDelivery { get; }

		bool QueuedDelivery { get; }
	}
	public interface IDuplexChannel : IChannel, ICommunicationObject, IInputChannel, IOutputChannel
	{
	}
	public interface IDuplexSession : IInputSession, ISession, IOutputSession
	{
		IAsyncResult BeginCloseOutputSession(AsyncCallback callback, object state);

		IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state);

		void CloseOutputSession();

		void CloseOutputSession(TimeSpan timeout);

		void EndCloseOutputSession(IAsyncResult result);
	}
	public interface IDuplexSessionChannel : IChannel, ICommunicationObject, IDuplexChannel, IInputChannel, IOutputChannel, ISessionChannel<IDuplexSession>
	{
	}
	public interface IInputChannel : IChannel, ICommunicationObject
	{
		EndpointAddress LocalAddress { get; }

		IAsyncResult BeginReceive(AsyncCallback callback, object state);

		IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, object state);

		IAsyncResult BeginTryReceive(TimeSpan timeout, AsyncCallback callback, object state);

		IAsyncResult BeginWaitForMessage(TimeSpan timeout, AsyncCallback callback, object state);

		Message EndReceive(IAsyncResult result);

		bool EndTryReceive(IAsyncResult result, out Message message);

		bool EndWaitForMessage(IAsyncResult result);

		Message Receive();

		Message Receive(TimeSpan timeout);

		bool TryReceive(TimeSpan timeout, out Message message);

		bool WaitForMessage(TimeSpan timeout);
	}
	public interface IInputSession : ISession
	{
	}
	public interface IInputSessionChannel : IChannel, ICommunicationObject, IInputChannel, ISessionChannel<IInputSession>
	{
	}
	public interface IMessageProperty
	{
		IMessageProperty CreateCopy();
	}
	public interface IOutputChannel : IChannel, ICommunicationObject
	{
		EndpointAddress RemoteAddress { get; }

		Uri Via { get; }

		IAsyncResult BeginSend(Message message, AsyncCallback callback, object state);

		IAsyncResult BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state);

		void EndSend(IAsyncResult result);

		void Send(Message message);

		void Send(Message message, TimeSpan timeout);
	}
	public interface IOutputSession : ISession
	{
	}
	public interface IOutputSessionChannel : IChannel, ICommunicationObject, IOutputChannel, ISessionChannel<IOutputSession>
	{
	}
	public interface IRequestChannel : IChannel, ICommunicationObject
	{
		EndpointAddress RemoteAddress { get; }

		Uri Via { get; }

		IAsyncResult BeginRequest(Message message, AsyncCallback callback, object state);

		IAsyncResult BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state);

		Message EndRequest(IAsyncResult result);

		Message Request(Message message);

		Message Request(Message message, TimeSpan timeout);
	}
	public interface IRequestSessionChannel : IChannel, ICommunicationObject, IRequestChannel, ISessionChannel<IOutputSession>
	{
	}
	public interface ISession
	{
		string Id { get; }
	}
	public interface ISessionChannel<TSession> where TSession : ISession
	{
		TSession Session { get; }
	}
	public abstract class Message : IDisposable
	{
		public abstract MessageHeaders Headers { get; }

		protected bool IsDisposed => false;

		public virtual bool IsEmpty => false;

		public virtual bool IsFault => false;

		public abstract MessageProperties Properties { get; }

		public MessageState State => MessageState.Created;

		public abstract MessageVersion Version { get; }

		public void Close()
		{
		}

		public MessageBuffer CreateBufferedCopy(int maxBufferSize)
		{
			return null;
		}

		public static Message CreateMessage(MessageVersion version, string action)
		{
			return null;
		}

		public static Message CreateMessage(MessageVersion version, string action, object body)
		{
			return null;
		}

		public static Message CreateMessage(MessageVersion version, string action, object body, XmlObjectSerializer serializer)
		{
			return null;
		}

		public static Message CreateMessage(MessageVersion version, string action, BodyWriter body)
		{
			return null;
		}

		public static Message CreateMessage(MessageVersion version, string action, XmlDictionaryReader body)
		{
			return null;
		}

		public static Message CreateMessage(MessageVersion version, string action, XmlReader body)
		{
			return null;
		}

		public static Message CreateMessage(XmlDictionaryReader envelopeReader, int maxSizeOfHeaders, MessageVersion version)
		{
			return null;
		}

		public static Message CreateMessage(XmlReader envelopeReader, int maxSizeOfHeaders, MessageVersion version)
		{
			return null;
		}

		public static Message CreateMessage(MessageVersion version, FaultCode faultCode, string reason, string action)
		{
			return null;
		}

		public static Message CreateMessage(MessageVersion version, FaultCode faultCode, string reason, object detail, string action)
		{
			return null;
		}

		public T GetBody<T>()
		{
			return default(T);
		}

		public T GetBody<T>(XmlObjectSerializer serializer)
		{
			return default(T);
		}

		public string GetBodyAttribute(string localName, string ns)
		{
			return null;
		}

		public XmlDictionaryReader GetReaderAtBodyContents()
		{
			return null;
		}

		protected virtual void OnBodyToString(XmlDictionaryWriter writer)
		{
		}

		protected virtual void OnClose()
		{
		}

		protected virtual MessageBuffer OnCreateBufferedCopy(int maxBufferSize)
		{
			return null;
		}

		protected virtual T OnGetBody<T>(XmlDictionaryReader reader)
		{
			return default(T);
		}

		protected virtual string OnGetBodyAttribute(string localName, string ns)
		{
			return null;
		}

		protected virtual XmlDictionaryReader OnGetReaderAtBodyContents()
		{
			return null;
		}

		protected abstract void OnWriteBodyContents(XmlDictionaryWriter writer);

		protected virtual void OnWriteMessage(XmlDictionaryWriter writer)
		{
		}

		protected virtual void OnWriteStartBody(XmlDictionaryWriter writer)
		{
		}

		protected virtual void OnWriteStartEnvelope(XmlDictionaryWriter writer)
		{
		}

		protected virtual void OnWriteStartHeaders(XmlDictionaryWriter writer)
		{
		}

		void IDisposable.Dispose()
		{
		}

		public override string ToString()
		{
			return null;
		}

		public void WriteBody(XmlDictionaryWriter writer)
		{
		}

		public void WriteBody(XmlWriter writer)
		{
		}

		public void WriteBodyContents(XmlDictionaryWriter writer)
		{
		}

		public void WriteMessage(XmlDictionaryWriter writer)
		{
		}

		public void WriteMessage(XmlWriter writer)
		{
		}

		public void WriteStartBody(XmlDictionaryWriter writer)
		{
		}

		public void WriteStartBody(XmlWriter writer)
		{
		}

		public void WriteStartEnvelope(XmlDictionaryWriter writer)
		{
		}
	}
	public abstract class MessageBuffer : IDisposable
	{
		public abstract int BufferSize { get; }

		public virtual string MessageContentType => null;

		public abstract void Close();

		public abstract Message CreateMessage();

		void IDisposable.Dispose()
		{
		}

		public virtual void WriteMessage(Stream stream)
		{
		}
	}
	public abstract class MessageEncoder
	{
		public abstract string ContentType { get; }

		public abstract string MediaType { get; }

		public abstract MessageVersion MessageVersion { get; }

		public virtual T GetProperty<T>() where T : class
		{
			return null;
		}

		public virtual bool IsContentTypeSupported(string contentType)
		{
			return false;
		}

		public Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager)
		{
			return null;
		}

		public abstract Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType);

		public Message ReadMessage(Stream stream, int maxSizeOfHeaders)
		{
			return null;
		}

		public abstract Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType);

		public override string ToString()
		{
			return null;
		}

		public ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager)
		{
			return default(ArraySegment<byte>);
		}

		public abstract ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset);

		public abstract void WriteMessage(Message message, Stream stream);
	}
	public abstract class MessageEncoderFactory
	{
		public abstract MessageEncoder Encoder { get; }

		public abstract MessageVersion MessageVersion { get; }

		public virtual MessageEncoder CreateSessionEncoder()
		{
			return null;
		}
	}
	public abstract class MessageEncodingBindingElement : BindingElement
	{
		public abstract MessageVersion MessageVersion { get; set; }

		protected MessageEncodingBindingElement()
		{
		}

		protected MessageEncodingBindingElement(MessageEncodingBindingElement elementToBeCloned)
		{
		}

		public abstract MessageEncoderFactory CreateMessageEncoderFactory();

		public override T GetProperty<T>(BindingContext context)
		{
			return null;
		}
	}
	public abstract class MessageFault
	{
		public virtual string Actor => null;

		public abstract FaultCode Code { get; }

		public abstract bool HasDetail { get; }

		public virtual string Node => null;

		public abstract FaultReason Reason { get; }

		public static MessageFault CreateFault(Message message, int maxBufferSize)
		{
			return null;
		}

		public T GetDetail<T>()
		{
			return default(T);
		}

		public T GetDetail<T>(XmlObjectSerializer serializer)
		{
			return default(T);
		}

		public XmlDictionaryReader GetReaderAtDetailContents()
		{
			return null;
		}

		protected virtual XmlDictionaryReader OnGetReaderAtDetailContents()
		{
			return null;
		}

		protected virtual void OnWriteDetail(XmlDictionaryWriter writer, EnvelopeVersion version)
		{
		}

		protected abstract void OnWriteDetailContents(XmlDictionaryWriter writer);

		protected virtual void OnWriteStartDetail(XmlDictionaryWriter writer, EnvelopeVersion version)
		{
		}
	}
	public abstract class MessageHeader : MessageHeaderInfo
	{
		public override string Actor => null;

		public override bool IsReferenceParameter => false;

		public override bool MustUnderstand => false;

		public override bool Relay => false;

		public static MessageHeader CreateHeader(string name, string ns, object value)
		{
			return null;
		}

		public static Mes