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 MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand)
		{
			return null;
		}

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

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

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

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

		public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand, string actor)
		{
			return null;
		}

		public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay)
		{
			return null;
		}

		public virtual bool IsMessageVersionSupported(MessageVersion messageVersion)
		{
			return false;
		}

		protected abstract void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion);

		protected virtual void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
		{
		}

		public override string ToString()
		{
			return null;
		}

		public void WriteHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
		{
		}

		public void WriteHeader(XmlWriter writer, MessageVersion messageVersion)
		{
		}

		protected void WriteHeaderAttributes(XmlDictionaryWriter writer, MessageVersion messageVersion)
		{
		}

		public void WriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
		{
		}

		public void WriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
		{
		}
	}
	public abstract class MessageHeaderInfo
	{
		public abstract string Actor { get; }

		public abstract bool IsReferenceParameter { get; }

		public abstract bool MustUnderstand { get; }

		public abstract string Name { get; }

		public abstract string Namespace { get; }

		public abstract bool Relay { get; }
	}
	public sealed class MessageHeaders : IEnumerable<MessageHeaderInfo>, IEnumerable
	{
		public string Action
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public int Count => 0;

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

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

		public MessageHeaderInfo this[int index] => null;

		public UniqueId MessageId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public MessageVersion MessageVersion => null;

		public UnderstoodHeaders UnderstoodHeaders => null;

		public UniqueId RelatesTo
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

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

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

		public MessageHeaders(MessageHeaders collection)
		{
		}

		public MessageHeaders(MessageVersion version)
		{
		}

		public MessageHeaders(MessageVersion version, int initialSize)
		{
		}

		public void Add(MessageHeader header)
		{
		}

		public void Clear()
		{
		}

		public void CopyHeaderFrom(Message message, int headerIndex)
		{
		}

		public void CopyHeaderFrom(MessageHeaders collection, int headerIndex)
		{
		}

		public void CopyHeadersFrom(Message message)
		{
		}

		public void CopyHeadersFrom(MessageHeaders collection)
		{
		}

		public void CopyTo(MessageHeaderInfo[] array, int index)
		{
		}

		public int FindHeader(string name, string ns)
		{
			return 0;
		}

		public int FindHeader(string name, string ns, params string[] actors)
		{
			return 0;
		}

		public IEnumerator<MessageHeaderInfo> GetEnumerator()
		{
			return null;
		}

		public T GetHeader<T>(int index)
		{
			return default(T);
		}

		public T GetHeader<T>(int index, XmlObjectSerializer serializer)
		{
			return default(T);
		}

		public T GetHeader<T>(string name, string ns)
		{
			return default(T);
		}

		public T GetHeader<T>(string name, string ns, XmlObjectSerializer serializer)
		{
			return default(T);
		}

		public T GetHeader<T>(string name, string ns, params string[] actors)
		{
			return default(T);
		}

		public XmlDictionaryReader GetReaderAtHeader(int headerIndex)
		{
			return null;
		}

		public bool HaveMandatoryHeadersBeenUnderstood()
		{
			return false;
		}

		public bool HaveMandatoryHeadersBeenUnderstood(params string[] actors)
		{
			return false;
		}

		public void Insert(int headerIndex, MessageHeader header)
		{
		}

		public void RemoveAll(string name, string ns)
		{
		}

		public void RemoveAt(int headerIndex)
		{
		}

		public void SetAction(XmlDictionaryString action)
		{
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return null;
		}

		public void WriteHeader(int headerIndex, XmlDictionaryWriter writer)
		{
		}

		public void WriteHeader(int headerIndex, XmlWriter writer)
		{
		}

		public void WriteHeaderContents(int headerIndex, XmlDictionaryWriter writer)
		{
		}

		public void WriteHeaderContents(int headerIndex, XmlWriter writer)
		{
		}

		public void WriteStartHeader(int headerIndex, XmlDictionaryWriter writer)
		{
		}

		public void WriteStartHeader(int headerIndex, XmlWriter writer)
		{
		}
	}
	public sealed class MessageProperties : ICollection<KeyValuePair<string, object>>, IEnumerable<KeyValuePair<string, object>>, IEnumerable, IDictionary<string, object>, IDisposable
	{
		public bool AllowOutputBatching
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public int Count => 0;

		public MessageEncoder Encoder
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public bool IsFixedSize => false;

		public object this[string name]
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public ICollection<string> Keys => null;

		bool ICollection<KeyValuePair<string, object>>.IsReadOnly => false;

		public SecurityMessageProperty Security
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public ICollection<object> Values => null;

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

		public MessageProperties()
		{
		}

		public MessageProperties(MessageProperties properties)
		{
		}

		public void Add(string name, object property)
		{
		}

		public void Clear()
		{
		}

		public bool ContainsKey(string name)
		{
			return false;
		}

		public void CopyProperties(MessageProperties properties)
		{
		}

		public void Dispose()
		{
		}

		public bool Remove(string name)
		{
			return false;
		}

		void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> pair)
		{
		}

		bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> pair)
		{
			return false;
		}

		void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object>[] array, int index)
		{
		}

		bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> pair)
		{
			return false;
		}

		IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator()
		{
			return null;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return null;
		}

		public bool TryGetValue(string name, out object value)
		{
			value = null;
			return false;
		}
	}
	public enum MessageState
	{
		Closed = 4,
		Copied = 3,
		Created = 0,
		Read = 1,
		Written = 2
	}
	public sealed class MessageVersion
	{
		public AddressingVersion Addressing => null;

		public static MessageVersion Default => null;

		public EnvelopeVersion Envelope => null;

		public static MessageVersion None => null;

		public static MessageVersion Soap11 => null;

		public static MessageVersion Soap11WSAddressing10 => null;

		public static MessageVersion Soap11WSAddressingAugust2004 => null;

		public static MessageVersion Soap12 => null;

		public static MessageVersion Soap12WSAddressing10 => null;

		public static MessageVersion Soap12WSAddressingAugust2004 => null;

		internal MessageVersion()
		{
		}

		public static MessageVersion CreateVersion(EnvelopeVersion envelopeVersion)
		{
			return null;
		}

		public static MessageVersion CreateVersion(EnvelopeVersion envelopeVersion, AddressingVersion addressingVersion)
		{
			return null;
		}

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

		public override int GetHashCode()
		{
			return 0;
		}

		public override string ToString()
		{
			return null;
		}
	}
	public sealed class MtomMessageEncodingBindingElement : MessageEncodingBindingElement
	{
		[DefaultValue(64)]
		public int MaxReadPoolSize { get; set; }

		[DefaultValue(16)]
		public int MaxWritePoolSize { get; set; }

		public XmlDictionaryReaderQuotas ReaderQuotas { get; }

		[DefaultValue(65536)]
		public int MaxBufferSize { get; set; }

		public Encoding WriteEncoding { get; set; }

		public override MessageVersion MessageVersion { get; set; }

		public MtomMessageEncodingBindingElement()
		{
		}

		public MtomMessageEncodingBindingElement(MessageVersion messageVersion, Encoding writeEncoding)
		{
		}

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

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

		public override BindingElement Clone()
		{
			return null;
		}

		public override MessageEncoderFactory CreateMessageEncoderFactory()
		{
			return null;
		}

		public override T GetProperty<T>(BindingContext context)
		{
			return null;
		}
	}
	public sealed class ReliableSessionBindingElement : BindingElement
	{
		public TimeSpan AcknowledgementInterval { get; set; }

		public bool FlowControlEnabled { get; set; }

		public TimeSpan InactivityTimeout { get; set; }

		public int MaxPendingChannels { get; set; }

		public int MaxRetryCount { get; set; }

		public int MaxTransferWindowSize { get; set; }

		public bool Ordered { get; set; }

		public ReliableMessagingVersion ReliableMessagingVersion { get; set; }

		public ReliableSessionBindingElement()
		{
		}

		public ReliableSessionBindingElement(bool ordered)
		{
		}

		public override BindingElement Clone()
		{
			return null;
		}

		public override T GetProperty<T>(BindingContext context)
		{
			return null;
		}

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

		public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
		{
			return false;
		}
	}
	public abstract class RequestContext : IDisposable
	{
		public abstract Message RequestMessage { get; }

		public abstract void Abort();

		public abstract IAsyncResult BeginReply(Message message, AsyncCallback callback, object state);

		public abstract IAsyncResult BeginReply(Message message, TimeSpan timeout, AsyncCallback callback, object state);

		public abstract void Close();

		public abstract void Close(TimeSpan timeout);

		protected virtual void Dispose(bool disposing)
		{
		}

		public abstract void EndReply(IAsyncResult result);

		public abstract void Reply(Message message);

		public abstract void Reply(Message message, TimeSpan timeout);

		void IDisposable.Dispose()
		{
		}
	}
	public sealed class TextMessageEncodingBindingElement : MessageEncodingBindingElement
	{
		public override MessageVersion MessageVersion
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

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

		public Encoding WriteEncoding
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public TextMessageEncodingBindingElement()
		{
		}

		public TextMessageEncodingBindingElement(MessageVersion messageVersion, Encoding writeEncoding)
		{
		}

		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 TransportBindingElement : BindingElement
	{
		[DefaultValue(false)]
		public virtual bool ManualAddressing
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		[DefaultValue(65536L)]
		public virtual long MaxReceivedMessageSize
		{
			get
			{
				return 0L;
			}
			set
			{
			}
		}

		[DefaultValue(524288L)]
		public virtual long MaxBufferPoolSize
		{
			get
			{
				return 0L;
			}
			set
			{
			}
		}

		public abstract string Scheme { get; }

		protected TransportBindingElement()
		{
		}

		protected TransportBindingElement(TransportBindingElement elementToBeCloned)
		{
		}

		public override T GetProperty<T>(BindingContext context)
		{
			return null;
		}
	}
	public sealed class UnderstoodHeaders : IEnumerable<MessageHeaderInfo>, IEnumerable
	{
		internal UnderstoodHeaders()
		{
		}

		public void Add(MessageHeaderInfo headerInfo)
		{
		}

		public bool Contains(MessageHeaderInfo headerInfo)
		{
			return false;
		}

		public IEnumerator<MessageHeaderInfo> GetEnumerator()
		{
			return null;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return null;
		}

		public void Remove(MessageHeaderInfo headerInfo)
		{
		}
	}
	public interface ISecurityCapabilities
	{
		ProtectionLevel SupportedRequestProtectionLevel { get; }

		ProtectionLevel SupportedResponseProtectionLevel { get; }

		bool SupportsClientAuthentication { get; }

		bool SupportsClientWindowsIdentity { get; }

		bool SupportsServerAuthentication { get; }
	}
	public sealed class LocalClientSecuritySettings
	{
		public bool DetectReplays
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public TimeSpan MaxClockSkew
		{
			get
			{
				return default(TimeSpan);
			}
			set
			{
			}
		}

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

		public TimeSpan ReplayWindow
		{
			get
			{
				return default(TimeSpan);
			}
			set
			{
			}
		}

		public TimeSpan TimestampValidityDuration
		{
			get
			{
				return default(TimeSpan);
			}
			set
			{
			}
		}

		public LocalClientSecuritySettings Clone()
		{
			return null;
		}
	}
	public abstract class SecurityBindingElement : BindingElement
	{
		public SupportingTokenParameters EndpointSupportingTokenParameters => null;

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

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

		public LocalClientSecuritySettings LocalClientSettings => null;

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

		public SecurityHeaderLayout SecurityHeaderLayout
		{
			get
			{
				return SecurityHeaderLayout.Strict;
			}
			set
			{
			}
		}

		public SecurityKeyEntropyMode KeyEntropyMode
		{
			get
			{
				return SecurityKeyEntropyMode.ClientEntropy;
			}
			set
			{
			}
		}

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

		internal SecurityBindingElement()
		{
		}

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

		protected abstract IChannelFactory<TChannel> BuildChannelFactoryCore<TChannel>(BindingContext context);

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

		public static SecurityBindingElement CreateSecureConversationBindingElement(SecurityBindingElement bootstrapSecurity)
		{
			return null;
		}

		public static TransportSecurityBindingElement CreateUserNameOverTransportBindingElement()
		{
			return null;
		}

		public static TransportSecurityBindingElement CreateIssuedTokenOverTransportBindingElement(IssuedSecurityTokenParameters issuedTokenParameters)
		{
			return null;
		}

		public static TransportSecurityBindingElement CreateCertificateOverTransportBindingElement()
		{
			return null;
		}

		public static TransportSecurityBindingElement CreateCertificateOverTransportBindingElement(MessageSecurityVersion version)
		{
			return null;
		}

		public override T GetProperty<T>(BindingContext context)
		{
			return null;
		}

		public override string ToString()
		{
			return null;
		}
	}
	public enum SecurityHeaderLayout
	{
		Lax = 1,
		Strict = 0
	}
	public sealed class TransportSecurityBindingElement : SecurityBindingElement
	{
		protected override IChannelFactory<TChannel> BuildChannelFactoryCore<TChannel>(BindingContext context)
		{
			return null;
		}

		public override BindingElement Clone()
		{
			return null;
		}

		public override T GetProperty<T>(BindingContext context)
		{
			return null;
		}
	}
}
namespace System.IdentityModel.Tokens
{
	public abstract class SecurityKey
	{
		public abstract int KeySize { get; }

		internal SecurityKey()
		{
		}
	}
	public class SecurityKeyIdentifier : IEnumerable<SecurityKeyIdentifierClause>, IEnumerable
	{
		public SecurityKeyIdentifierClause this[int index] => null;

		public bool CanCreateKey => false;

		public int Count => 0;

		public bool IsReadOnly => false;

		public SecurityKeyIdentifier()
		{
		}

		public SecurityKeyIdentifier(params SecurityKeyIdentifierClause[] clauses)
		{
		}

		public void Add(SecurityKeyIdentifierClause clause)
		{
		}

		public SecurityKey CreateKey()
		{
			return null;
		}

		public TClause Find<TClause>() where TClause : SecurityKeyIdentifierClause
		{
			return null;
		}

		public IEnumerator<SecurityKeyIdentifierClause> GetEnumerator()
		{
			return null;
		}

		public void MakeReadOnly()
		{
		}

		public override string ToString()
		{
			return null;
		}

		public bool TryFind<TClause>(out TClause clause) where TClause : SecurityKeyIdentifierClause
		{
			clause = null;
			return false;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return null;
		}
	}
	public abstract class SecurityKeyIdentifierClause
	{
		public virtual bool CanCreateKey => false;

		public string ClauseType => null;

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

		public int DerivationLength => 0;

		protected SecurityKeyIdentifierClause(string clauseType)
		{
		}

		protected SecurityKeyIdentifierClause(string clauseType, byte[] nonce, int length)
		{
		}

		public virtual SecurityKey CreateKey()
		{
			return null;
		}

		public virtual bool Matches(SecurityKeyIdentifierClause keyIdentifierClause)
		{
			return false;
		}

		public byte[] GetDerivationNonce()
		{
			return null;
		}
	}
	public abstract class SecurityToken
	{
		public abstract string Id { get; }

		public abstract ReadOnlyCollection<SecurityKey> SecurityKeys { get; }

		public abstract DateTime ValidFrom { get; }

		public abstract DateTime ValidTo { get; }

		public virtual bool CanCreateKeyIdentifierClause<T>() where T : SecurityKeyIdentifierClause
		{
			return false;
		}

		public virtual T CreateKeyIdentifierClause<T>() where T : SecurityKeyIdentifierClause
		{
			return null;
		}

		public virtual bool MatchesKeyIdentifierClause(SecurityKeyIdentifierClause keyIdentifierClause)
		{
			return false;
		}

		public virtual SecurityKey ResolveKeyIdentifierClause(SecurityKeyIdentifierClause keyIdentifierClause)
		{
			return null;
		}
	}
	public abstract class SymmetricSecurityKey : SecurityKey
	{
		public abstract SymmetricAlgorithm GetSymmetricAlgorithm(string algorithm);

		public abstract byte[] GetSymmetricKey();
	}
	public class GenericXmlSecurityToken : SecurityToken
	{
		public override string Id => null;

		public override DateTime ValidFrom => default(DateTime);

		public override DateTime ValidTo => default(DateTime);

		public SecurityKeyIdentifierClause InternalTokenReference => null;

		public SecurityKeyIdentifierClause ExternalTokenReference => null;

		public XmlElement TokenXml => null;

		public SecurityToken ProofToken => null;

		public ReadOnlyCollection<IAuthorizationPolicy> AuthorizationPolicies => null;

		public override ReadOnlyCollection<SecurityKey> SecurityKeys => null;

		public GenericXmlSecurityToken(XmlElement tokenXml, SecurityToken proofToken, DateTime effectiveTime, DateTime expirationTime, SecurityKeyIdentifierClause internalTokenReference, SecurityKeyIdentifierClause externalTokenReference, ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies)
		{
		}

		public override bool CanCreateKeyIdentifierClause<T>()
		{
			return false;
		}

		public override T CreateKeyIdentifierClause<T>()
		{
			return null;
		}

		public override bool MatchesKeyIdentifierClause(SecurityKeyIdentifierClause keyIdentifierClause)
		{
			return false;
		}

		public override string ToString()
		{
			return null;
		}
	}
	public class GenericXmlSecurityKeyIdentifierClause : SecurityKeyIdentifierClause
	{
		public XmlElement ReferenceXml => null;

		public GenericXmlSecurityKeyIdentifierClause(XmlElement referenceXml)
			: this(referenceXml, null, 0)
		{
		}

		public GenericXmlSecurityKeyIdentifierClause(XmlElement referenceXml, byte[] derivationNonce, int derivationLength)
			: base(null, derivationNonce, derivationLength)
		{
		}

		public override bool Matches(SecurityKeyIdentifierClause keyIdentifierClause)
		{
			return false;
		}
	}
	public enum SecurityKeyType
	{
		SymmetricKey,
		AsymmetricKey,
		BearerKey
	}
	public enum SecurityKeyUsage
	{
		Exchange,
		Signature
	}
	[Serializable]
	public class SecurityTokenException : Exception
	{
		public SecurityTokenException()
		{
		}

		public SecurityTokenException(string message)
		{
		}

		public SecurityTokenException(string message, Exception innerException)
		{
		}

		protected SecurityTokenException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	[Serializable]
	public class SecurityTokenValidationException : SecurityTokenException
	{
		public SecurityTokenValidationException()
		{
		}

		public SecurityTokenValidationException(string message)
		{
		}

		public SecurityTokenValidationException(string message, Exception innerException)
		{
		}

		protected SecurityTokenValidationException(SerializationInfo info, StreamingContext context)
		{
		}
	}
	public class UserNameSecurityToken : SecurityToken
	{
		public override string Id => null;

		public override ReadOnlyCollection<SecurityKey> SecurityKeys => null;

		public override DateTime ValidFrom => default(DateTime);

		public override DateTime ValidTo => default(DateTime);

		public string UserName => null;

		public string Password => null;

		public UserNameSecurityToken(string userName, string password)
		{
		}

		public UserNameSecurityToken(string userName, string password, string id)
		{
		}
	}
	public class X509SecurityToken : SecurityToken, IDisposable
	{
		public override string Id => null;

		public override ReadOnlyCollection<SecurityKey> SecurityKeys => null;

		public override DateTime ValidFrom => default(DateTime);

		public override DateTime ValidTo => default(DateTime);

		public X509Certificate2 Certificate => null;

		public X509SecurityToken(X509Certificate2 certificate)
		{
		}

		public X509SecurityToken(X509Certificate2 certificate, string id)
		{
		}

		public override bool CanCreateKeyIdentifierClause<T>()
		{
			return false;
		}

		public override T CreateKeyIdentifierClause<T>()
		{
			return null;
		}

		public override bool MatchesKeyIdentifierClause(SecurityKeyIdentifierClause keyIdentifierClause)
		{
			return false;
		}

		public virtual void Dispose()
		{
		}

		protected void ThrowIfDisposed()
		{
		}
	}
}
namespace System.IdentityModel.Selectors
{
	public abstract class SecurityTokenAuthenticator
	{
		public bool CanValidateToken(SecurityToken token)
		{
			return false;
		}

		public ReadOnlyCollection<IAuthorizationPolicy> ValidateToken(SecurityToken token)
		{
			return null;
		}

		protected abstract bool CanValidateTokenCore(SecurityToken token);

		protected abstract ReadOnlyCollection<IAuthorizationPolicy> ValidateTokenCore(SecurityToken token);
	}
	public abstract class SecurityTokenManager
	{
		public abstract SecurityTokenProvider CreateSecurityTokenProvider(SecurityTokenRequirement tokenRequirement);

		public abstract SecurityTokenSerializer CreateSecurityTokenSerializer(SecurityTokenVersion version);

		public abstract SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver);
	}
	public abstract class SecurityTokenProvider
	{
		public virtual bool SupportsTokenRenewal => false;

		public virtual bool SupportsTokenCancellation => false;

		public SecurityToken GetToken(TimeSpan timeout)
		{
			return null;
		}

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

		public SecurityToken EndGetToken(IAsyncResult result)
		{
			return null;
		}

		public SecurityToken RenewToken(TimeSpan timeout, SecurityToken tokenToBeRenewed)
		{
			return null;
		}

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

		public SecurityToken EndRenewToken(IAsyncResult result)
		{
			return null;
		}

		public void CancelToken(TimeSpan timeout, SecurityToken token)
		{
		}

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

		public void EndCancelToken(IAsyncResult result)
		{
		}

		protected abstract SecurityToken GetTokenCore(TimeSpan timeout);

		protected virtual SecurityToken RenewTokenCore(TimeSpan timeout, SecurityToken tokenToBeRenewed)
		{
			return null;
		}

		protected virtual void CancelTokenCore(TimeSpan timeout, SecurityToken token)
		{
		}

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

		protected virtual SecurityToken EndGetTokenCore(IAsyncResult result)
		{
			return null;
		}

		protected virtual IAsyncResult BeginRenewTokenCore(TimeSpan timeout, SecurityToken tokenToBeRenewed, AsyncCallback callback, object state)
		{
			return null;
		}

		protected virtual SecurityToken EndRenewTokenCore(IAsyncResult result)
		{
			return null;
		}

		protected virtual IAsyncResult BeginCancelTokenCore(TimeSpan timeout, SecurityToken token, AsyncCallback callback, object state)
		{
			return null;
		}

		protected virtual void EndCancelTokenCore(IAsyncResult result)
		{
		}
	}
	public class SecurityTokenRequirement
	{
		public string TokenType
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

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

		public SecurityKeyUsage KeyUsage
		{
			get
			{
				return SecurityKeyUsage.Exchange;
			}
			set
			{
			}
		}

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

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

		public IDictionary<string, object> Properties => null;

		public TValue GetProperty<TValue>(string propertyName)
		{
			return default(TValue);
		}

		public bool TryGetProperty<TValue>(string propertyName, out TValue result)
		{
			result = default(TValue);
			return false;
		}
	}
	public abstract class SecurityTokenResolver
	{
		internal SecurityTokenResolver()
		{
		}
	}
	public abstract class SecurityTokenSerializer
	{
		public bool CanReadToken(XmlReader reader)
		{
			return false;
		}

		public bool CanWriteToken(SecurityToken token)
		{
			return false;
		}

		public bool CanReadKeyIdentifier(XmlReader reader)
		{
			return false;
		}

		public bool CanWriteKeyIdentifier(SecurityKeyIdentifier keyIdentifier)
		{
			return false;
		}

		public bool CanReadKeyIdentifierClause(XmlReader reader)
		{
			return false;
		}

		public bool CanWriteKeyIdentifierClause(SecurityKeyIdentifierClause keyIdentifierClause)
		{
			return false;
		}

		public SecurityToken ReadToken(XmlReader reader, SecurityTokenResolver tokenResolver)
		{
			return null;
		}

		public void WriteToken(XmlWriter writer, SecurityToken token)
		{
		}

		public SecurityKeyIdentifier ReadKeyIdentifier(XmlReader reader)
		{
			return null;
		}

		public void WriteKeyIdentifier(XmlWriter writer, SecurityKeyIdentifier keyIdentifier)
		{
		}

		public SecurityKeyIdentifierClause ReadKeyIdentifierClause(XmlReader reader)
		{
			return null;
		}

		public void WriteKeyIdentifierClause(XmlWriter writer, SecurityKeyIdentifierClause keyIdentifierClause)
		{
		}

		protected abstract bool CanReadTokenCore(XmlReader reader);

		protected abstract bool CanWriteTokenCore(SecurityToken token);

		protected abstract bool CanReadKeyIdentifierCore(XmlReader reader);

		protected abstract bool CanWriteKeyIdentifierCore(SecurityKeyIdentifier keyIdentifier);

		protected abstract bool CanReadKeyIdentifierClauseCore(XmlReader reader);

		protected abstract bool CanWriteKeyIdentifierClauseCore(SecurityKeyIdentifierClause keyIdentifierClause);

		protected abstract SecurityToken ReadTokenCore(XmlReader reader, SecurityTokenResolver tokenResolver);

		protected abstract void WriteTokenCore(XmlWriter writer, SecurityToken token);

		protected abstract SecurityKeyIdentifier ReadKeyIdentifierCore(XmlReader reader);

		protected abstract void WriteKeyIdentifierCore(XmlWriter writer, SecurityKeyIdentifier keyIdentifier);

		protected abstract SecurityKeyIdentifierClause ReadKeyIdentifierClauseCore(XmlReader reader);

		protected abstract void WriteKeyIdentifierClauseCore(XmlWriter writer, SecurityKeyIdentifierClause keyIdentifierClause);
	}
	public abstract class SecurityTokenVersion
	{
		public abstract ReadOnlyCollection<string> GetSecuritySpecifications();
	}
	public abstract class X509CertificateValidator
	{
		public abstract void Validate(X509Certificate2 certificate);

		public static X509CertificateValidator CreateChainTrustValidator(bool useMachineContext, X509ChainPolicy chainPolicy)
		{
			return null;
		}
	}
	public class X509SecurityTokenAuthenticator : SecurityTokenAuthenticator
	{
		public X509SecurityTokenAuthenticator()
		{
		}

		public X509SecurityTokenAuthenticator(X509CertificateValidator validator)
		{
		}

		protected override bool CanValidateTokenCore(SecurityToken token)
		{
			return false;
		}

		protected override ReadOnlyCollection<IAuthorizationPolicy> ValidateTokenCore(SecurityToken token)
		{
			return null;
		}
	}
}
namespace System.IdentityModel.Policy
{
	public interface IAuthorizationPolicy
	{
		ClaimSet Issuer { get; }

		bool Evaluate(EvaluationContext evaluationContext, ref object state);
	}
	public interface IAuthorizationComponent
	{
		string Id { get; }
	}
	public abstract class AuthorizationContext : IAuthorizationComponent
	{
		public abstract string Id { get; }

		public abstract ReadOnlyCollection<ClaimSet> ClaimSets { get; }

		public abstract DateTime ExpirationTime { get; }

		public abstract IDictionary<string, object> Properties { get; }

		public static AuthorizationContext CreateDefaultAuthorizationContext(IList<IAuthorizationPolicy> authorizationPolicies)
		{
			return null;
		}
	}
	public abstract class EvaluationContext
	{
		public abstract ReadOnlyCollection<ClaimSet> ClaimSets { get; }

		public abstract IDictionary<string, object> Properties { get; }

		public abstract int Generation { get; }

		public abstract void AddClaimSet(IAuthorizationPolicy policy, ClaimSet claimSet);

		public abstract void RecordExpirationTime(DateTime expirationTime);
	}
}
namespace System.IdentityModel.Claims
{
	public abstract class ClaimSet : IEnumerable<Claim>, IEnumerable
	{
		public static ClaimSet System => null;

		public abstract Claim this[int index] { get; }

		public abstract int Count { get; }

		public abstract ClaimSet Issuer { get; }

		public virtual bool ContainsClaim(Claim claim, IEqualityComparer<Claim> comparer)
		{
			return false;
		}

		public virtual bool ContainsClaim(Claim claim)
		{
			return false;
		}

		public abstract IEnumerable<Claim> FindClaims(string claimType, string right);

		public abstract IEnumerator<Claim> GetEnumerator();

		IEnumerator IEnumerable.GetEnumerator()
		{
			return null;
		}
	}
	public class Claim
	{
		public static IEqualityComparer<Claim> DefaultComparer => null;

		public static Claim System => null;

		public object Resource => null;

		public string ClaimType => null;

		public string Right => null;

		public Claim(string claimType, object resource, string right)
		{
		}

		public static Claim CreateDnsClaim(string dns)
		{
			return null;
		}

		public static Claim CreateHashClaim(byte[] hash)
		{
			return null;
		}

		public static Claim CreateNameClaim(string name)
		{
			return null;
		}

		public static Claim CreateRsaClaim(RSA rsa)
		{
			return null;
		}

		public static Claim CreateSpnClaim(string spn)
		{
			return null;
		}

		public static Claim CreateThumbprintClaim(byte[] thumbprint)
		{
			return null;
		}

		public static Claim CreateUpnClaim(string upn)
		{
			return null;
		}

		public static Claim CreateUriClaim(Uri uri)
		{
			return null;
		}

		public static Claim CreateWindowsSidClaim(SecurityIdentifier sid)
		{
			return null;
		}

		public static Claim CreateX500DistinguishedNameClaim(X500DistinguishedName x500DistinguishedName)
		{
			return null;
		}

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

		public override int GetHashCode()
		{
			return 0;
		}

		public override string ToString()
		{
			return null;
		}
	}
	public static class ClaimTypes
	{
		public static string Anonymous => null;

		public static string DenyOnlySid => null;

		public static string Dns => null;

		public static string Email => null;

		public static string Hash => null;

		public static string Name => null;

		public static string Rsa => null;

		public static string Sid => null;

		public static string Spn => null;

		public static string System => null;

		public static string Thumbprint => null;

		public static string Upn => null;

		public static string Uri => null;

		public static string X500DistinguishedName => null;

		public static string NameIdentifier => null;

		public static string Authentication => null;

		public static string AuthorizationDecision => null;
	}
	public class DefaultClaimSet : ClaimSet
	{
		public override Claim this[int index] => null;

		public override int Count => 0;

		public override ClaimSet Issuer => null;

		public DefaultClaimSet(params Claim[] claims)
		{
		}

		public DefaultClaimSet(IList<Claim> claims)
		{
		}

		public DefaultClaimSet(ClaimSet issuer, params Claim[] claims)
		{
		}

		public DefaultClaimSet(ClaimSet issuer, IList<Claim> claims)
		{
		}

		public override bool ContainsClaim(Claim claim)
		{
			return false;
		}

		public override IEnumerable<Claim> FindClaims(string claimType, string right)
		{
			return null;
		}

		public override IEnumerator<Claim> GetEnumerator()
		{
			return null;
		}

		protected void Initialize(ClaimSet issuer, IList<Claim> claims)
		{
		}

		public override string ToString()
		{
			return null;
		}
	}
	public class X509CertificateClaimSet : ClaimSet, IDisposable
	{
		public override Claim this[int index] => null;

		public override int Count => 0;

		public DateTime ExpirationTime => default(DateTime);

		public override ClaimSet Issuer => null;

		public X509Certificate2 X509Certificate => null;

		public X509CertificateClaimSet(X509Certificate2 certificate)
		{
		}

		public void Dispose()
		{
		}

		public override IEnumerable<Claim> FindClaims(string claimType, string right)
		{
			return null;
		}

		public override IEnumerator<Claim> GetEnumerator()
		{
			return null;
		}

		public override string ToString()
		{
			return null;
		}
	}
}
namespace System.Collections.Generic
{
	public class SynchronizedCollection<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection
	{
		public int Count => 0;

		protected List<T> Items => null;

		public object SyncRoot => null;

		public T this[int index]
		{
			get
			{
				return default(T);
			}
			set
			{
			}
		}

		bool ICollection<T>.IsReadOnly => false;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => null;

		object IList.this[int index]
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		bool IList.IsReadOnly => false;

		bool IList.IsFixedSize => false;

		public SynchronizedCollection()
		{
		}

		public SynchronizedCollection(object syncRoot)
		{
		}

		public SynchronizedCollection(object syncRoot, IEnumerable<T> list)
		{
		}

		public SynchronizedCollection(object syncRoot, params T[] list)
		{
		}

		public void Add(T item)
		{
		}

		public void Clear()
		{
		}

		public void CopyTo(T[] array, int index)
		{
		}

		public bool Contains(T item)
		{
			return false;
		}

		public IEnumerator<T> GetEnumerator()
		{
			return null;
		}

		public int IndexOf(T item)
		{
			return 0;
		}

		public void Insert(int index, T item)
		{
		}

		public bool Remove(T item)
		{
			return false;
		}

		public void RemoveAt(int index)
		{
		}

		protected virtual void ClearItems()
		{
		}

		protected virtual void InsertItem(int index, T item)
		{
		}

		protected virtual void RemoveItem(int index)
		{
		}

		protected virtual void SetItem(int index, T item)
		{
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return null;
		}

		void ICollection.CopyTo(Array array, int index)
		{
		}

		int IList.Add(object value)
		{
			return 0;
		}

		bool IList.Contains(object value)
		{
			return false;
		}

		int IList.IndexOf(object value)
		{
			return 0;
		}

		void IList.Insert(int index, object value)
		{
		}

		void IList.Remove(object value)
		{
		}
	}
	public class KeyedByTypeCollection<TItem> : KeyedCollection<Type, TItem>
	{
		public KeyedByTypeCollection()
		{
		}

		public KeyedByTypeCollection(IEnumerable<TItem> items)
		{
		}

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

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

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

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

		protected override Type GetKeyForItem(TItem item)
		{
			return null;
		}

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

		protected override void SetItem(int index, TItem item)
		{
		}
	}
}