System.TypeLoadException: Could not load type 'System.Security.Cryptography.Aes' from assembly 'mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'.
namespace System
{
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    public class Lazy`1<T>
    {
        public Lazy`1();
        public Lazy`1(bool isThreadSafe);
        public Lazy`1(Func`1<T> valueFactory);
        public Lazy`1(Func`1<T> valueFactory, bool isThreadSafe);
        public bool IsValueCreated { get; }
        public T Value { get; }
        public override string ToString();
    }

    public sealed class TimeZoneInfo: IEquatable`1
    {
        public TimeSpan BaseUtcOffset { get; }
        public string DaylightName { get; }
        public string DisplayName { get; }
        public static TimeZoneInfo Local { get; }
        public string StandardName { get; }
        public bool SupportsDaylightSavingTime { get; }
        public static TimeZoneInfo Utc { get; }
        public static DateTime ConvertTime(DateTime dateTime, TimeZoneInfo destinationTimeZone);
        public static DateTimeOffset ConvertTime(DateTimeOffset dateTimeOffset, TimeZoneInfo destinationTimeZone);
        public bool Equals(TimeZoneInfo other);
        public TimeSpan[] GetAmbiguousTimeOffsets(DateTime dateTime);
        public TimeSpan[] GetAmbiguousTimeOffsets(DateTimeOffset dateTimeOffset);
        public override int GetHashCode();
        public TimeSpan GetUtcOffset(DateTime dateTime);
        public TimeSpan GetUtcOffset(DateTimeOffset dateTimeOffset);
        public bool IsAmbiguousTime(DateTime dateTime);
        public bool IsAmbiguousTime(DateTimeOffset dateTimeOffset);
        public bool IsDaylightSavingTime(DateTime dateTime);
        public bool IsDaylightSavingTime(DateTimeOffset dateTimeOffset);
        public bool IsInvalidTime(DateTime dateTime);
        public override string ToString();
    }

    public delegate void Action();

    public delegate void Action`10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);

    public delegate void Action`11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);

    public delegate void Action`12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);

    public delegate void Action`13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);

    public delegate void Action`14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);

    public delegate void Action`15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);

    public delegate void Action`16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);

    public delegate void Action`2<T1,T2>(T1 arg1, T2 arg2);

    public delegate void Action`3<T1,T2,T3>(T1 arg1, T2 arg2, T3 arg3);

    public delegate void Action`4<T1,T2,T3,T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    public delegate void Action`5<T1,T2,T3,T4,T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    public delegate void Action`6<T1,T2,T3,T4,T5,T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);

    public delegate void Action`7<T1,T2,T3,T4,T5,T6,T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);

    public delegate void Action`8<T1,T2,T3,T4,T5,T6,T7,T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);

    public delegate void Action`9<T1,T2,T3,T4,T5,T6,T7,T8,T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);

    public delegate TResult Func`1<TResult>();

    public delegate TResult Func`10<T1,T2,T3,T4,T5,T6,T7,T8,T9,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);

    public delegate TResult Func`11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);

    public delegate TResult Func`12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);

    public delegate TResult Func`13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);

    public delegate TResult Func`14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);

    public delegate TResult Func`15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);

    public delegate TResult Func`16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);

    public delegate TResult Func`17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);

    public delegate TResult Func`2<T,TResult>(T arg);

    public delegate TResult Func`3<T1,T2,TResult>(T1 arg1, T2 arg2);

    public delegate TResult Func`4<T1,T2,T3,TResult>(T1 arg1, T2 arg2, T3 arg3);

    public delegate TResult Func`5<T1,T2,T3,T4,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    public delegate TResult Func`6<T1,T2,T3,T4,T5,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    public delegate TResult Func`7<T1,T2,T3,T4,T5,T6,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);

    public delegate TResult Func`8<T1,T2,T3,T4,T5,T6,T7,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);

    public delegate TResult Func`9<T1,T2,T3,T4,T5,T6,T7,T8,TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);

    public class InvalidTimeZoneException: Exception, _Exception, ISerializable
    {
        public InvalidTimeZoneException();
        public InvalidTimeZoneException(string message);
        public InvalidTimeZoneException(string message, Exception innerException);
    }

} 

namespace System.Collections.Generic
{
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    public class HashSet`1<T>: ISet`1<T>
    {
        public HashSet`1();
        public HashSet`1(IEnumerable`1<T> collection);
        public HashSet`1(IEnumerable`1<T> collection, IEqualityComparer`1<T> comparer);
        public HashSet`1(IEqualityComparer`1<T> comparer);
        public IEqualityComparer`1<T> Comparer { get; }
        public int Count { get; }
        public bool Add(T item);
        public void Clear();
        public bool Contains(T item);
        public void CopyTo(T[] array);
        public void CopyTo(T[] array, int arrayIndex);
        public void CopyTo(T[] array, int arrayIndex, int count);
        public void ExceptWith(IEnumerable`1<T> other);
        public Enumerator<T> GetEnumerator();
        public void IntersectWith(IEnumerable`1<T> other);
        public bool IsProperSubsetOf(IEnumerable`1<T> other);
        public bool IsProperSupersetOf(IEnumerable`1<T> other);
        public bool IsSubsetOf(IEnumerable`1<T> other);
        public bool IsSupersetOf(IEnumerable`1<T> other);
        public bool Overlaps(IEnumerable`1<T> other);
        public bool Remove(T item);
        public int RemoveWhere(Predicate`1<T> match);
        public bool SetEquals(IEnumerable`1<T> other);
        public void SymmetricExceptWith(IEnumerable`1<T> other);
        public void TrimExcess();
        public void UnionWith(IEnumerable`1<T> other);
    }

} 

namespace System.Dynamic
{
    public abstract class BinaryOperationBinder: DynamicMetaObjectBinder
    {
        protected BinaryOperationBinder(ExpressionType operation);
        public ExpressionType Operation { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackBinaryOperation(DynamicMetaObject target, DynamicMetaObject arg);
        public abstract DynamicMetaObject FallbackBinaryOperation(DynamicMetaObject target, DynamicMetaObject arg, DynamicMetaObject errorSuggestion);
    }

    public abstract class BindingRestrictions
    {
        public static readonly BindingRestrictions Empty;
        public static BindingRestrictions Combine(IList`1<DynamicMetaObject> contributingObjects);
        public static BindingRestrictions GetExpressionRestriction(Expression expression);
        public static BindingRestrictions GetInstanceRestriction(Expression expression, object instance);
        public static BindingRestrictions GetTypeRestriction(Expression expression, Type type);
        public BindingRestrictions Merge(BindingRestrictions restrictions);
        public Expression ToExpression();
    }

    public sealed class CallInfo
    {
        public CallInfo(int argCount, IEnumerable`1<string> argNames);
        public CallInfo(int argCount, params string[] argNames);
        public int ArgumentCount { get; }
        public ReadOnlyCollection`1<string> ArgumentNames { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
    }

    public abstract class ConvertBinder: DynamicMetaObjectBinder
    {
        protected ConvertBinder(Type type, bool explicit);
        public bool Explicit { get; }
        public Type Type { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackConvert(DynamicMetaObject target);
        public abstract DynamicMetaObject FallbackConvert(DynamicMetaObject target, DynamicMetaObject errorSuggestion);
    }

    public abstract class CreateInstanceBinder: DynamicMetaObjectBinder
    {
        protected CreateInstanceBinder(CallInfo callInfo);
        public CallInfo CallInfo { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args);
        public abstract DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion);
    }

    public abstract class DeleteIndexBinder: DynamicMetaObjectBinder
    {
        protected DeleteIndexBinder(CallInfo callInfo);
        public CallInfo CallInfo { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackDeleteIndex(DynamicMetaObject target, DynamicMetaObject[] indexes);
        public abstract DynamicMetaObject FallbackDeleteIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion);
    }

    public abstract class DeleteMemberBinder: DynamicMetaObjectBinder
    {
        protected DeleteMemberBinder(string name, bool ignoreCase);
        public bool IgnoreCase { get; }
        public string Name { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackDeleteMember(DynamicMetaObject target);
        public abstract DynamicMetaObject FallbackDeleteMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion);
    }

    public class DynamicMetaObject
    {
        public DynamicMetaObject(Expression expression, BindingRestrictions restrictions);
        public DynamicMetaObject(Expression expression, BindingRestrictions restrictions, object value);
        public static readonly DynamicMetaObject[] EmptyMetaObjects;
        public Expression Expression { get; }
        public bool HasValue { get; }
        public Type LimitType { get; }
        public BindingRestrictions Restrictions { get; }
        public Type RuntimeType { get; }
        public object Value { get; }
        public virtual DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg);
        public virtual DynamicMetaObject BindConvert(ConvertBinder binder);
        public virtual DynamicMetaObject BindCreateInstance(CreateInstanceBinder binder, DynamicMetaObject[] args);
        public virtual DynamicMetaObject BindDeleteIndex(DeleteIndexBinder binder, DynamicMetaObject[] indexes);
        public virtual DynamicMetaObject BindDeleteMember(DeleteMemberBinder binder);
        public virtual DynamicMetaObject BindGetIndex(GetIndexBinder binder, DynamicMetaObject[] indexes);
        public virtual DynamicMetaObject BindGetMember(GetMemberBinder binder);
        public virtual DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args);
        public virtual DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args);
        public virtual DynamicMetaObject BindSetIndex(SetIndexBinder binder, DynamicMetaObject[] indexes, DynamicMetaObject value);
        public virtual DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value);
        public virtual DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder);
        public static DynamicMetaObject Create(object value, Expression expression);
        public virtual IEnumerable`1<string> GetDynamicMemberNames();
    }

    public abstract class DynamicMetaObjectBinder: CallSiteBinder
    {
        protected DynamicMetaObjectBinder();
        public virtual Type ReturnType { get; }
        public abstract DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public sealed override Expression Bind(object[] args, ReadOnlyCollection`1<ParameterExpression> parameters, LabelTarget returnLabel);
        public DynamicMetaObject Defer(DynamicMetaObject target, params DynamicMetaObject[] args);
        public DynamicMetaObject Defer(params DynamicMetaObject[] args);
        public Expression GetUpdateExpression(Type type);
    }

    public class DynamicObject: IDynamicMetaObjectProvider
    {
        protected DynamicObject();
        public virtual IEnumerable`1<string> GetDynamicMemberNames();
        public virtual DynamicMetaObject GetMetaObject(Expression parameter);
        public virtual bool TryBinaryOperation(BinaryOperationBinder binder, object arg, ref object result);
        public virtual bool TryConvert(ConvertBinder binder, ref object result);
        public virtual bool TryCreateInstance(CreateInstanceBinder binder, object[] args, ref object result);
        public virtual bool TryDeleteIndex(DeleteIndexBinder binder, object[] indexes);
        public virtual bool TryDeleteMember(DeleteMemberBinder binder);
        public virtual bool TryGetIndex(GetIndexBinder binder, object[] indexes, ref object result);
        public virtual bool TryGetMember(GetMemberBinder binder, ref object result);
        public virtual bool TryInvoke(InvokeBinder binder, object[] args, ref object result);
        public virtual bool TryInvokeMember(InvokeMemberBinder binder, object[] args, ref object result);
        public virtual bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value);
        public virtual bool TrySetMember(SetMemberBinder binder, object value);
        public virtual bool TryUnaryOperation(UnaryOperationBinder binder, ref object result);
    }

    public abstract class GetIndexBinder: DynamicMetaObjectBinder
    {
        protected GetIndexBinder(CallInfo callInfo);
        public CallInfo CallInfo { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackGetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes);
        public abstract DynamicMetaObject FallbackGetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion);
    }

    public abstract class GetMemberBinder: DynamicMetaObjectBinder
    {
        protected GetMemberBinder(string name, bool ignoreCase);
        public bool IgnoreCase { get; }
        public string Name { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackGetMember(DynamicMetaObject target);
        public abstract DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion);
    }

    public interface IDynamicMetaObjectProvider
    {
        public DynamicMetaObject GetMetaObject(Expression parameter);
    }

    public interface IInvokeOnGetBinder
    {
        public bool InvokeOnGet { get; }
    }

    public abstract class InvokeBinder: DynamicMetaObjectBinder
    {
        protected InvokeBinder(CallInfo callInfo);
        public CallInfo CallInfo { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args);
        public abstract DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion);
    }

    public abstract class InvokeMemberBinder: DynamicMetaObjectBinder
    {
        protected InvokeMemberBinder(string name, bool ignoreCase, CallInfo callInfo);
        public CallInfo CallInfo { get; }
        public bool IgnoreCase { get; }
        public string Name { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public abstract DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion);
        public DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args);
        public abstract DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion);
    }

    public abstract class SetIndexBinder: DynamicMetaObjectBinder
    {
        protected SetIndexBinder(CallInfo callInfo);
        public CallInfo CallInfo { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackSetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value);
        public abstract DynamicMetaObject FallbackSetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion);
    }

    public abstract class SetMemberBinder: DynamicMetaObjectBinder
    {
        protected SetMemberBinder(string name, bool ignoreCase);
        public bool IgnoreCase { get; }
        public string Name { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value);
        public abstract DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value, DynamicMetaObject errorSuggestion);
    }

    public abstract class UnaryOperationBinder: DynamicMetaObjectBinder
    {
        protected UnaryOperationBinder(ExpressionType operation);
        public ExpressionType Operation { get; }
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args);
        public DynamicMetaObject FallbackUnaryOperation(DynamicMetaObject target);
        public abstract DynamicMetaObject FallbackUnaryOperation(DynamicMetaObject target, DynamicMetaObject errorSuggestion);
    }

    public sealed class ExpandoObject: IDictionary`2, IDynamicMetaObjectProvider, INotifyPropertyChanged
    {
        public ExpandoObject();
    }

} 

namespace System.Linq
{
    [ExtensionAttribute(..)]
    public abstract sealed class Enumerable
    {
        public static TSource Aggregate<TSource>(IEnumerable`1<TSource> source, Func`3<TSource,TSource,TSource> func);
        public static TAccumulate Aggregate<TSource,TAccumulate>(IEnumerable`1<TSource> source, TAccumulate seed, Func`3<TAccumulate,TSource,TAccumulate> func);
        public static TResult Aggregate<TSource,TAccumulate,TResult>(IEnumerable`1<TSource> source, TAccumulate seed, Func`3<TAccumulate,TSource,TAccumulate> func, Func`2<TAccumulate,TResult> resultSelector);
        public static bool All<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static bool Any<TSource>(IEnumerable`1<TSource> source);
        public static bool Any<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static IEnumerable`1<TSource> AsEnumerable<TSource>(IEnumerable`1<TSource> source);
        public static Nullable`1<double> Average(IEnumerable`1<Nullable`1<double>> source);
        public static Nullable`1<decimal> Average(IEnumerable`1<Nullable`1<decimal>> source);
        public static decimal Average(IEnumerable`1<decimal> source);
        public static Nullable`1<double> Average(IEnumerable`1<Nullable`1<int>> source);
        public static double Average(IEnumerable`1<long> source);
        public static float Average(IEnumerable`1<float> source);
        public static double Average(IEnumerable`1<int> source);
        public static Nullable`1<float> Average(IEnumerable`1<Nullable`1<float>> source);
        public static double Average(IEnumerable`1<double> source);
        public static Nullable`1<double> Average(IEnumerable`1<Nullable`1<long>> source);
        public static double Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,int> selector);
        public static Nullable`1<float> Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<float>> selector);
        public static double Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,long> selector);
        public static Nullable`1<double> Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<int>> selector);
        public static decimal Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,decimal> selector);
        public static Nullable`1<decimal> Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<decimal>> selector);
        public static Nullable`1<double> Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<double>> selector);
        public static Nullable`1<double> Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<long>> selector);
        public static float Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,float> selector);
        public static double Average<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,double> selector);
        public static IEnumerable`1<TResult> Cast<TResult>(IEnumerable source);
        public static IEnumerable`1<TSource> Concat<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second);
        public static bool Contains<TSource>(IEnumerable`1<TSource> source, TSource value);
        public static bool Contains<TSource>(IEnumerable`1<TSource> source, TSource value, IEqualityComparer`1<TSource> comparer);
        public static int Count<TSource>(IEnumerable`1<TSource> source);
        public static int Count<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static IEnumerable`1<TSource> DefaultIfEmpty<TSource>(IEnumerable`1<TSource> source);
        public static IEnumerable`1<TSource> DefaultIfEmpty<TSource>(IEnumerable`1<TSource> source, TSource defaultValue);
        public static IEnumerable`1<TSource> Distinct<TSource>(IEnumerable`1<TSource> source);
        public static IEnumerable`1<TSource> Distinct<TSource>(IEnumerable`1<TSource> source, IEqualityComparer`1<TSource> comparer);
        public static TSource ElementAt<TSource>(IEnumerable`1<TSource> source, int index);
        public static TSource ElementAtOrDefault<TSource>(IEnumerable`1<TSource> source, int index);
        public static IEnumerable`1<TResult> Empty<TResult>();
        public static IEnumerable`1<TSource> Except<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second);
        public static IEnumerable`1<TSource> Except<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second, IEqualityComparer`1<TSource> comparer);
        public static TSource First<TSource>(IEnumerable`1<TSource> source);
        public static TSource First<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static TSource FirstOrDefault<TSource>(IEnumerable`1<TSource> source);
        public static TSource FirstOrDefault<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static IEnumerable`1<IGrouping`2<TKey,TSource>> GroupBy<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector);
        public static IEnumerable`1<IGrouping`2<TKey,TElement>> GroupBy<TSource,TKey,TElement>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`2<TSource,TElement> elementSelector);
        public static IEnumerable`1<TResult> GroupBy<TSource,TKey,TElement,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`2<TSource,TElement> elementSelector, Func`3<TKey,IEnumerable`1<TElement>,TResult> resultSelector);
        public static IEnumerable`1<TResult> GroupBy<TSource,TKey,TElement,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`2<TSource,TElement> elementSelector, Func`3<TKey,IEnumerable`1<TElement>,TResult> resultSelector, IEqualityComparer`1<TKey> comparer);
        public static IEnumerable`1<IGrouping`2<TKey,TElement>> GroupBy<TSource,TKey,TElement>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`2<TSource,TElement> elementSelector, IEqualityComparer`1<TKey> comparer);
        public static IEnumerable`1<TResult> GroupBy<TSource,TKey,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`3<TKey,IEnumerable`1<TSource>,TResult> resultSelector);
        public static IEnumerable`1<TResult> GroupBy<TSource,TKey,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`3<TKey,IEnumerable`1<TSource>,TResult> resultSelector, IEqualityComparer`1<TKey> comparer);
        public static IEnumerable`1<IGrouping`2<TKey,TSource>> GroupBy<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, IEqualityComparer`1<TKey> comparer);
        public static IEnumerable`1<TResult> GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable`1<TOuter> outer, IEnumerable`1<TInner> inner, Func`2<TOuter,TKey> outerKeySelector, Func`2<TInner,TKey> innerKeySelector, Func`3<TOuter,IEnumerable`1<TInner>,TResult> resultSelector);
        public static IEnumerable`1<TResult> GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable`1<TOuter> outer, IEnumerable`1<TInner> inner, Func`2<TOuter,TKey> outerKeySelector, Func`2<TInner,TKey> innerKeySelector, Func`3<TOuter,IEnumerable`1<TInner>,TResult> resultSelector, IEqualityComparer`1<TKey> comparer);
        public static IEnumerable`1<TSource> Intersect<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second);
        public static IEnumerable`1<TSource> Intersect<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second, IEqualityComparer`1<TSource> comparer);
        public static IEnumerable`1<TResult> Join<TOuter,TInner,TKey,TResult>(IEnumerable`1<TOuter> outer, IEnumerable`1<TInner> inner, Func`2<TOuter,TKey> outerKeySelector, Func`2<TInner,TKey> innerKeySelector, Func`3<TOuter,TInner,TResult> resultSelector);
        public static IEnumerable`1<TResult> Join<TOuter,TInner,TKey,TResult>(IEnumerable`1<TOuter> outer, IEnumerable`1<TInner> inner, Func`2<TOuter,TKey> outerKeySelector, Func`2<TInner,TKey> innerKeySelector, Func`3<TOuter,TInner,TResult> resultSelector, IEqualityComparer`1<TKey> comparer);
        public static TSource Last<TSource>(IEnumerable`1<TSource> source);
        public static TSource Last<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static TSource LastOrDefault<TSource>(IEnumerable`1<TSource> source);
        public static TSource LastOrDefault<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static long LongCount<TSource>(IEnumerable`1<TSource> source);
        public static long LongCount<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static Nullable`1<int> Max(IEnumerable`1<Nullable`1<int>> source);
        public static Nullable`1<decimal> Max(IEnumerable`1<Nullable`1<decimal>> source);
        public static Nullable`1<double> Max(IEnumerable`1<Nullable`1<double>> source);
        public static int Max(IEnumerable`1<int> source);
        public static Nullable`1<float> Max(IEnumerable`1<Nullable`1<float>> source);
        public static float Max(IEnumerable`1<float> source);
        public static decimal Max(IEnumerable`1<decimal> source);
        public static TSource Max<TSource>(IEnumerable`1<TSource> source);
        public static long Max(IEnumerable`1<long> source);
        public static Nullable`1<long> Max(IEnumerable`1<Nullable`1<long>> source);
        public static double Max(IEnumerable`1<double> source);
        public static long Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,long> selector);
        public static Nullable`1<long> Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<long>> selector);
        public static double Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,double> selector);
        public static Nullable`1<float> Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<float>> selector);
        public static float Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,float> selector);
        public static Nullable`1<double> Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<double>> selector);
        public static decimal Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,decimal> selector);
        public static Nullable`1<decimal> Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<decimal>> selector);
        public static TResult Max<TSource,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,TResult> selector);
        public static Nullable`1<int> Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<int>> selector);
        public static int Max<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,int> selector);
        public static float Min(IEnumerable`1<float> source);
        public static Nullable`1<long> Min(IEnumerable`1<Nullable`1<long>> source);
        public static Nullable`1<decimal> Min(IEnumerable`1<Nullable`1<decimal>> source);
        public static TSource Min<TSource>(IEnumerable`1<TSource> source);
        public static int Min(IEnumerable`1<int> source);
        public static Nullable`1<float> Min(IEnumerable`1<Nullable`1<float>> source);
        public static double Min(IEnumerable`1<double> source);
        public static decimal Min(IEnumerable`1<decimal> source);
        public static Nullable`1<double> Min(IEnumerable`1<Nullable`1<double>> source);
        public static Nullable`1<int> Min(IEnumerable`1<Nullable`1<int>> source);
        public static long Min(IEnumerable`1<long> source);
        public static decimal Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,decimal> selector);
        public static Nullable`1<double> Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<double>> selector);
        public static Nullable`1<decimal> Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<decimal>> selector);
        public static Nullable`1<int> Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<int>> selector);
        public static TResult Min<TSource,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,TResult> selector);
        public static float Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,float> selector);
        public static Nullable`1<long> Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<long>> selector);
        public static long Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,long> selector);
        public static int Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,int> selector);
        public static Nullable`1<float> Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<float>> selector);
        public static double Min<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,double> selector);
        public static IEnumerable`1<TResult> OfType<TResult>(IEnumerable source);
        public static IOrderedEnumerable`1<TSource> OrderBy<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector);
        public static IOrderedEnumerable`1<TSource> OrderBy<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, IComparer`1<TKey> comparer);
        public static IOrderedEnumerable`1<TSource> OrderByDescending<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector);
        public static IOrderedEnumerable`1<TSource> OrderByDescending<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, IComparer`1<TKey> comparer);
        public static IEnumerable`1<int> Range(int start, int count);
        public static IEnumerable`1<TResult> Repeat<TResult>(TResult element, int count);
        public static IEnumerable`1<TSource> Reverse<TSource>(IEnumerable`1<TSource> source);
        public static IEnumerable`1<TResult> Select<TSource,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,TResult> selector);
        public static IEnumerable`1<TResult> Select<TSource,TResult>(IEnumerable`1<TSource> source, Func`3<TSource,int,TResult> selector);
        public static IEnumerable`1<TResult> SelectMany<TSource,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,IEnumerable`1<TResult>> selector);
        public static IEnumerable`1<TResult> SelectMany<TSource,TCollection,TResult>(IEnumerable`1<TSource> source, Func`2<TSource,IEnumerable`1<TCollection>> collectionSelector, Func`3<TSource,TCollection,TResult> resultSelector);
        public static IEnumerable`1<TResult> SelectMany<TSource,TResult>(IEnumerable`1<TSource> source, Func`3<TSource,int,IEnumerable`1<TResult>> selector);
        public static IEnumerable`1<TResult> SelectMany<TSource,TCollection,TResult>(IEnumerable`1<TSource> source, Func`3<TSource,int,IEnumerable`1<TCollection>> collectionSelector, Func`3<TSource,TCollection,TResult> resultSelector);
        public static bool SequenceEqual<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second);
        public static bool SequenceEqual<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second, IEqualityComparer`1<TSource> comparer);
        public static TSource Single<TSource>(IEnumerable`1<TSource> source);
        public static TSource Single<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static TSource SingleOrDefault<TSource>(IEnumerable`1<TSource> source);
        public static TSource SingleOrDefault<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static IEnumerable`1<TSource> Skip<TSource>(IEnumerable`1<TSource> source, int count);
        public static IEnumerable`1<TSource> SkipWhile<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static IEnumerable`1<TSource> SkipWhile<TSource>(IEnumerable`1<TSource> source, Func`3<TSource,int,bool> predicate);
        public static double Sum(IEnumerable`1<double> source);
        public static Nullable`1<float> Sum(IEnumerable`1<Nullable`1<float>> source);
        public static Nullable`1<double> Sum(IEnumerable`1<Nullable`1<double>> source);
        public static Nullable`1<decimal> Sum(IEnumerable`1<Nullable`1<decimal>> source);
        public static decimal Sum(IEnumerable`1<decimal> source);
        public static Nullable`1<int> Sum(IEnumerable`1<Nullable`1<int>> source);
        public static int Sum(IEnumerable`1<int> source);
        public static long Sum(IEnumerable`1<long> source);
        public static float Sum(IEnumerable`1<float> source);
        public static Nullable`1<long> Sum(IEnumerable`1<Nullable`1<long>> source);
        public static double Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,double> selector);
        public static Nullable`1<float> Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<float>> selector);
        public static Nullable`1<double> Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<double>> selector);
        public static Nullable`1<decimal> Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<decimal>> selector);
        public static decimal Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,decimal> selector);
        public static Nullable`1<int> Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<int>> selector);
        public static long Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,long> selector);
        public static int Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,int> selector);
        public static float Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,float> selector);
        public static Nullable`1<long> Sum<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,Nullable`1<long>> selector);
        public static IEnumerable`1<TSource> Take<TSource>(IEnumerable`1<TSource> source, int count);
        public static IEnumerable`1<TSource> TakeWhile<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static IEnumerable`1<TSource> TakeWhile<TSource>(IEnumerable`1<TSource> source, Func`3<TSource,int,bool> predicate);
        public static IOrderedEnumerable`1<TSource> ThenBy<TSource,TKey>(IOrderedEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector);
        public static IOrderedEnumerable`1<TSource> ThenBy<TSource,TKey>(IOrderedEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, IComparer`1<TKey> comparer);
        public static IOrderedEnumerable`1<TSource> ThenByDescending<TSource,TKey>(IOrderedEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector);
        public static IOrderedEnumerable`1<TSource> ThenByDescending<TSource,TKey>(IOrderedEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, IComparer`1<TKey> comparer);
        public static TSource[] ToArray<TSource>(IEnumerable`1<TSource> source);
        public static Dictionary`2<TKey,TSource> ToDictionary<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector);
        public static Dictionary`2<TKey,TElement> ToDictionary<TSource,TKey,TElement>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`2<TSource,TElement> elementSelector);
        public static Dictionary`2<TKey,TElement> ToDictionary<TSource,TKey,TElement>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`2<TSource,TElement> elementSelector, IEqualityComparer`1<TKey> comparer);
        public static Dictionary`2<TKey,TSource> ToDictionary<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, IEqualityComparer`1<TKey> comparer);
        public static List`1<TSource> ToList<TSource>(IEnumerable`1<TSource> source);
        public static ILookup`2<TKey,TSource> ToLookup<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector);
        public static ILookup`2<TKey,TElement> ToLookup<TSource,TKey,TElement>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`2<TSource,TElement> elementSelector);
        public static ILookup`2<TKey,TElement> ToLookup<TSource,TKey,TElement>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, Func`2<TSource,TElement> elementSelector, IEqualityComparer`1<TKey> comparer);
        public static ILookup`2<TKey,TSource> ToLookup<TSource,TKey>(IEnumerable`1<TSource> source, Func`2<TSource,TKey> keySelector, IEqualityComparer`1<TKey> comparer);
        public static IEnumerable`1<TSource> Union<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second);
        public static IEnumerable`1<TSource> Union<TSource>(IEnumerable`1<TSource> first, IEnumerable`1<TSource> second, IEqualityComparer`1<TSource> comparer);
        public static IEnumerable`1<TSource> Where<TSource>(IEnumerable`1<TSource> source, Func`2<TSource,bool> predicate);
        public static IEnumerable`1<TSource> Where<TSource>(IEnumerable`1<TSource> source, Func`3<TSource,int,bool> predicate);
        public static IEnumerable`1<TResult> Zip<TFirst,TSecond,TResult>(IEnumerable`1<TFirst> first, IEnumerable`1<TSecond> second, Func`3<TFirst,TSecond,TResult> resultSelector);
    }

    public abstract class EnumerableExecutor
    {
        protected EnumerableExecutor();
    }

    public class EnumerableExecutor`1<T>: EnumerableExecutor
    {
        public EnumerableExecutor`1(Expression expression);
    }

    public abstract class EnumerableQuery
    {
        protected EnumerableQuery();
    }

    public interface IQueryProvider
    {
        public IQueryable`1<TElement> CreateQuery<TElement>(Expression expression);
        public IQueryable CreateQuery(Expression expression);
        public TResult Execute<TResult>(Expression expression);
        public object Execute(Expression expression);
    }

    [ExtensionAttribute(..)]
    public abstract sealed class Queryable
    {
        public static TSource Aggregate<TSource>(IQueryable`1<TSource> source, Expression`1<Func`3<TSource,TSource,TSource>> func);
        public static TAccumulate Aggregate<TSource,TAccumulate>(IQueryable`1<TSource> source, TAccumulate seed, Expression`1<Func`3<TAccumulate,TSource,TAccumulate>> func);
        public static TResult Aggregate<TSource,TAccumulate,TResult>(IQueryable`1<TSource> source, TAccumulate seed, Expression`1<Func`3<TAccumulate,TSource,TAccumulate>> func, Expression`1<Func`2<TAccumulate,TResult>> selector);
        public static bool All<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static bool Any<TSource>(IQueryable`1<TSource> source);
        public static bool Any<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static IQueryable AsQueryable(IEnumerable source);
        public static IQueryable`1<TElement> AsQueryable<TElement>(IEnumerable`1<TElement> source);
        public static double Average(IQueryable`1<double> source);
        public static Nullable`1<double> Average(IQueryable`1<Nullable`1<int>> source);
        public static float Average(IQueryable`1<float> source);
        public static double Average(IQueryable`1<long> source);
        public static Nullable`1<float> Average(IQueryable`1<Nullable`1<float>> source);
        public static Nullable`1<double> Average(IQueryable`1<Nullable`1<double>> source);
        public static Nullable`1<double> Average(IQueryable`1<Nullable`1<long>> source);
        public static double Average(IQueryable`1<int> source);
        public static Nullable`1<decimal> Average(IQueryable`1<Nullable`1<decimal>> source);
        public static decimal Average(IQueryable`1<decimal> source);
        public static float Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,float>> selector);
        public static Nullable`1<float> Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<float>>> selector);
        public static Nullable`1<double> Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<long>>> selector);
        public static double Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,int>> selector);
        public static Nullable`1<double> Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<int>>> selector);
        public static decimal Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,decimal>> selector);
        public static Nullable`1<decimal> Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<decimal>>> selector);
        public static Nullable`1<double> Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<double>>> selector);
        public static double Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,long>> selector);
        public static double Average<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,double>> selector);
        public static IQueryable`1<TResult> Cast<TResult>(IQueryable source);
        public static IQueryable`1<TSource> Concat<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2);
        public static bool Contains<TSource>(IQueryable`1<TSource> source, TSource item);
        public static bool Contains<TSource>(IQueryable`1<TSource> source, TSource item, IEqualityComparer`1<TSource> comparer);
        public static int Count<TSource>(IQueryable`1<TSource> source);
        public static int Count<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static IQueryable`1<TSource> DefaultIfEmpty<TSource>(IQueryable`1<TSource> source);
        public static IQueryable`1<TSource> DefaultIfEmpty<TSource>(IQueryable`1<TSource> source, TSource defaultValue);
        public static IQueryable`1<TSource> Distinct<TSource>(IQueryable`1<TSource> source);
        public static IQueryable`1<TSource> Distinct<TSource>(IQueryable`1<TSource> source, IEqualityComparer`1<TSource> comparer);
        public static TSource ElementAt<TSource>(IQueryable`1<TSource> source, int index);
        public static TSource ElementAtOrDefault<TSource>(IQueryable`1<TSource> source, int index);
        public static IQueryable`1<TSource> Except<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2);
        public static IQueryable`1<TSource> Except<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2, IEqualityComparer`1<TSource> comparer);
        public static TSource First<TSource>(IQueryable`1<TSource> source);
        public static TSource First<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static TSource FirstOrDefault<TSource>(IQueryable`1<TSource> source);
        public static TSource FirstOrDefault<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static IQueryable`1<IGrouping`2<TKey,TSource>> GroupBy<TSource,TKey>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector);
        public static IQueryable`1<TResult> GroupBy<TSource,TKey,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, Expression`1<Func`3<TKey,IEnumerable`1<TSource>,TResult>> resultSelector);
        public static IQueryable`1<IGrouping`2<TKey,TElement>> GroupBy<TSource,TKey,TElement>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, Expression`1<Func`2<TSource,TElement>> elementSelector);
        public static IQueryable`1<TResult> GroupBy<TSource,TKey,TElement,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, Expression`1<Func`2<TSource,TElement>> elementSelector, Expression`1<Func`3<TKey,IEnumerable`1<TElement>,TResult>> resultSelector);
        public static IQueryable`1<TResult> GroupBy<TSource,TKey,TElement,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, Expression`1<Func`2<TSource,TElement>> elementSelector, Expression`1<Func`3<TKey,IEnumerable`1<TElement>,TResult>> resultSelector, IEqualityComparer`1<TKey> comparer);
        public static IQueryable`1<IGrouping`2<TKey,TElement>> GroupBy<TSource,TKey,TElement>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, Expression`1<Func`2<TSource,TElement>> elementSelector, IEqualityComparer`1<TKey> comparer);
        public static IQueryable`1<TResult> GroupBy<TSource,TKey,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, Expression`1<Func`3<TKey,IEnumerable`1<TSource>,TResult>> resultSelector, IEqualityComparer`1<TKey> comparer);
        public static IQueryable`1<IGrouping`2<TKey,TSource>> GroupBy<TSource,TKey>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, IEqualityComparer`1<TKey> comparer);
        public static IQueryable`1<TResult> GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable`1<TOuter> outer, IEnumerable`1<TInner> inner, Expression`1<Func`2<TOuter,TKey>> outerKeySelector, Expression`1<Func`2<TInner,TKey>> innerKeySelector, Expression`1<Func`3<TOuter,IEnumerable`1<TInner>,TResult>> resultSelector);
        public static IQueryable`1<TResult> GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable`1<TOuter> outer, IEnumerable`1<TInner> inner, Expression`1<Func`2<TOuter,TKey>> outerKeySelector, Expression`1<Func`2<TInner,TKey>> innerKeySelector, Expression`1<Func`3<TOuter,IEnumerable`1<TInner>,TResult>> resultSelector, IEqualityComparer`1<TKey> comparer);
        public static IQueryable`1<TSource> Intersect<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2);
        public static IQueryable`1<TSource> Intersect<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2, IEqualityComparer`1<TSource> comparer);
        public static IQueryable`1<TResult> Join<TOuter,TInner,TKey,TResult>(IQueryable`1<TOuter> outer, IEnumerable`1<TInner> inner, Expression`1<Func`2<TOuter,TKey>> outerKeySelector, Expression`1<Func`2<TInner,TKey>> innerKeySelector, Expression`1<Func`3<TOuter,TInner,TResult>> resultSelector);
        public static IQueryable`1<TResult> Join<TOuter,TInner,TKey,TResult>(IQueryable`1<TOuter> outer, IEnumerable`1<TInner> inner, Expression`1<Func`2<TOuter,TKey>> outerKeySelector, Expression`1<Func`2<TInner,TKey>> innerKeySelector, Expression`1<Func`3<TOuter,TInner,TResult>> resultSelector, IEqualityComparer`1<TKey> comparer);
        public static TSource Last<TSource>(IQueryable`1<TSource> source);
        public static TSource Last<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static TSource LastOrDefault<TSource>(IQueryable`1<TSource> source);
        public static TSource LastOrDefault<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static long LongCount<TSource>(IQueryable`1<TSource> source);
        public static long LongCount<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static TSource Max<TSource>(IQueryable`1<TSource> source);
        public static TResult Max<TSource,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TResult>> selector);
        public static TSource Min<TSource>(IQueryable`1<TSource> source);
        public static TResult Min<TSource,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TResult>> selector);
        public static IQueryable`1<TResult> OfType<TResult>(IQueryable source);
        public static IOrderedQueryable`1<TSource> OrderBy<TSource,TKey>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector);
        public static IOrderedQueryable`1<TSource> OrderBy<TSource,TKey>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, IComparer`1<TKey> comparer);
        public static IOrderedQueryable`1<TSource> OrderByDescending<TSource,TKey>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector);
        public static IOrderedQueryable`1<TSource> OrderByDescending<TSource,TKey>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, IComparer`1<TKey> comparer);
        public static IQueryable`1<TSource> Reverse<TSource>(IQueryable`1<TSource> source);
        public static IQueryable`1<TResult> Select<TSource,TResult>(IQueryable`1<TSource> source, Expression`1<Func`3<TSource,int,TResult>> selector);
        public static IQueryable`1<TResult> Select<TSource,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,TResult>> selector);
        public static IQueryable`1<TResult> SelectMany<TSource,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,IEnumerable`1<TResult>>> selector);
        public static IQueryable`1<TResult> SelectMany<TSource,TResult>(IQueryable`1<TSource> source, Expression`1<Func`3<TSource,int,IEnumerable`1<TResult>>> selector);
        public static IQueryable`1<TResult> SelectMany<TSource,TCollection,TResult>(IQueryable`1<TSource> source, Expression`1<Func`3<TSource,int,IEnumerable`1<TCollection>>> collectionSelector, Expression`1<Func`3<TSource,TCollection,TResult>> resultSelector);
        public static IQueryable`1<TResult> SelectMany<TSource,TCollection,TResult>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,IEnumerable`1<TCollection>>> collectionSelector, Expression`1<Func`3<TSource,TCollection,TResult>> resultSelector);
        public static bool SequenceEqual<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2);
        public static bool SequenceEqual<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2, IEqualityComparer`1<TSource> comparer);
        public static TSource Single<TSource>(IQueryable`1<TSource> source);
        public static TSource Single<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static TSource SingleOrDefault<TSource>(IQueryable`1<TSource> source);
        public static TSource SingleOrDefault<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static IQueryable`1<TSource> Skip<TSource>(IQueryable`1<TSource> source, int count);
        public static IQueryable`1<TSource> SkipWhile<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static IQueryable`1<TSource> SkipWhile<TSource>(IQueryable`1<TSource> source, Expression`1<Func`3<TSource,int,bool>> predicate);
        public static double Sum(IQueryable`1<double> source);
        public static float Sum(IQueryable`1<float> source);
        public static Nullable`1<double> Sum(IQueryable`1<Nullable`1<double>> source);
        public static Nullable`1<decimal> Sum(IQueryable`1<Nullable`1<decimal>> source);
        public static decimal Sum(IQueryable`1<decimal> source);
        public static Nullable`1<int> Sum(IQueryable`1<Nullable`1<int>> source);
        public static int Sum(IQueryable`1<int> source);
        public static Nullable`1<float> Sum(IQueryable`1<Nullable`1<float>> source);
        public static Nullable`1<long> Sum(IQueryable`1<Nullable`1<long>> source);
        public static long Sum(IQueryable`1<long> source);
        public static Nullable`1<int> Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<int>>> selector);
        public static long Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,long>> selector);
        public static double Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,double>> selector);
        public static int Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,int>> selector);
        public static Nullable`1<long> Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<long>>> selector);
        public static Nullable`1<decimal> Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<decimal>>> selector);
        public static decimal Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,decimal>> selector);
        public static Nullable`1<double> Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<double>>> selector);
        public static float Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,float>> selector);
        public static Nullable`1<float> Sum<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,Nullable`1<float>>> selector);
        public static IQueryable`1<TSource> Take<TSource>(IQueryable`1<TSource> source, int count);
        public static IQueryable`1<TSource> TakeWhile<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static IQueryable`1<TSource> TakeWhile<TSource>(IQueryable`1<TSource> source, Expression`1<Func`3<TSource,int,bool>> predicate);
        public static IOrderedQueryable`1<TSource> ThenBy<TSource,TKey>(IOrderedQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector);
        public static IOrderedQueryable`1<TSource> ThenBy<TSource,TKey>(IOrderedQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, IComparer`1<TKey> comparer);
        public static IOrderedQueryable`1<TSource> ThenByDescending<TSource,TKey>(IOrderedQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector);
        public static IOrderedQueryable`1<TSource> ThenByDescending<TSource,TKey>(IOrderedQueryable`1<TSource> source, Expression`1<Func`2<TSource,TKey>> keySelector, IComparer`1<TKey> comparer);
        public static IQueryable`1<TSource> Union<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2);
        public static IQueryable`1<TSource> Union<TSource>(IQueryable`1<TSource> source1, IEnumerable`1<TSource> source2, IEqualityComparer`1<TSource> comparer);
        public static IQueryable`1<TSource> Where<TSource>(IQueryable`1<TSource> source, Expression`1<Func`3<TSource,int,bool>> predicate);
        public static IQueryable`1<TSource> Where<TSource>(IQueryable`1<TSource> source, Expression`1<Func`2<TSource,bool>> predicate);
        public static IQueryable`1<TResult> Zip<TFirst,TSecond,TResult>(IQueryable`1<TFirst> source1, IEnumerable`1<TSecond> source2, Expression`1<Func`3<TFirst,TSecond,TResult>> resultSelector);
    }

    public class EnumerableQuery`1<T>: EnumerableQuery, IOrderedQueryable`1<T>, IQueryProvider
    {
        public EnumerableQuery`1(Expression expression);
        public EnumerableQuery`1(IEnumerable`1<T> enumerable);
        public override string ToString();
    }

    public interface IGrouping`2<TKey,TElement>: IEnumerable`1<TElement>
    {
        public TKey Key { get; }
    }

    [DefaultMemberAttribute(..)]
    public interface ILookup`2<TKey,TElement>: IEnumerable`1<IGrouping`2>
    {
        public int Count { get; }
        public IEnumerable`1<TElement> this[TKey key] { get; }
        public bool Contains(TKey key);
    }

    public interface IOrderedEnumerable`1<TElement>: IEnumerable`1<TElement>
    {
        public IOrderedEnumerable`1<TElement> CreateOrderedEnumerable<TKey>(Func`2<TElement,TKey> keySelector, IComparer`1<TKey> comparer, bool descending);
    }

    public interface IOrderedQueryable: IQueryable
    {
    }

    public interface IOrderedQueryable`1<T>: IOrderedQueryable, IQueryable`1<T>
    {
    }

    public interface IQueryable: IEnumerable
    {
        public Type ElementType { get; }
        public Expression Expression { get; }
        public IQueryProvider Provider { get; }
    }

    public interface IQueryable`1<T>: IEnumerable`1<T>, IQueryable
    {
    }

    [DefaultMemberAttribute(..)]
    public class Lookup`2<TKey,TElement>: ILookup`2<TKey, TElement>
    {
        public int Count { get; }
        public IEnumerable`1<TElement> this[TKey key] { get; }
        public IEnumerable`1<TResult> ApplyResultSelector<TResult>(Func`3<TKey,IEnumerable`1<TElement>,TResult> resultSelector);
        public bool Contains(TKey key);
        public IEnumerator`1<IGrouping`2<TKey,TElement>> GetEnumerator();
    }

} 

namespace System.Linq.Expressions
{
    public class BinaryExpression: Expression
    {
        public LambdaExpression Conversion { get; }
        public bool IsLifted { get; }
        public bool IsLiftedToNull { get; }
        public Expression Left { get; }
        public MethodInfo Method { get; }
        public Expression Right { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public override Expression Reduce();
        public BinaryExpression Update(Expression left, LambdaExpression conversion, Expression right);
    }

    public class BlockExpression: Expression
    {
        public ReadOnlyCollection`1<Expression> Expressions { get; }
        public Expression Result { get; }
        public ReadOnlyCollection`1<ParameterExpression> Variables { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public BlockExpression Update(IEnumerable`1<ParameterExpression> variables, IEnumerable`1<Expression> expressions);
    }

    public sealed class CatchBlock
    {
        public Expression Body { get; }
        public Expression Filter { get; }
        public Type Test { get; }
        public ParameterExpression Variable { get; }
        public override string ToString();
        public CatchBlock Update(ParameterExpression variable, Expression filter, Expression body);
    }

    public class ConditionalExpression: Expression
    {
        public Expression IfFalse { get; }
        public Expression IfTrue { get; }
        public Expression Test { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public ConditionalExpression Update(Expression test, Expression ifTrue, Expression ifFalse);
    }

    public class ConstantExpression: Expression
    {
        public object Value { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
    }

    public class DebugInfoExpression: Expression
    {
        public SymbolDocumentInfo Document { get; }
        public virtual int EndColumn { get; }
        public virtual int EndLine { get; }
        public virtual bool IsClear { get; }
        public virtual int StartColumn { get; }
        public virtual int StartLine { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
    }

    public sealed class DefaultExpression: Expression
    {
        protected override Expression Accept(ExpressionVisitor visitor);
    }

    public class DynamicExpression: Expression
    {
        public ReadOnlyCollection`1<Expression> Arguments { get; }
        public CallSiteBinder Binder { get; }
        public Type DelegateType { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public DynamicExpression Update(IEnumerable`1<Expression> arguments);
    }

    public sealed class ElementInit
    {
        public MethodInfo AddMethod { get; }
        public ReadOnlyCollection`1<Expression> Arguments { get; }
        public override string ToString();
        public ElementInit Update(IEnumerable`1<Expression> arguments);
    }

    public abstract class Expression
    {
        protected Expression();
        protected Expression(ExpressionType nodeType, Type type);
        public virtual bool CanReduce { get; }
        public virtual ExpressionType NodeType { get; }
        public virtual Type Type { get; }
        protected virtual Expression Accept(ExpressionVisitor visitor);
        public static BinaryExpression Add(Expression left, Expression right);
        public static BinaryExpression Add(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression AddAssign(Expression left, Expression right);
        public static BinaryExpression AddAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression AddAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression AddAssignChecked(Expression left, Expression right);
        public static BinaryExpression AddAssignChecked(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression AddAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression AddChecked(Expression left, Expression right);
        public static BinaryExpression AddChecked(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression And(Expression left, Expression right);
        public static BinaryExpression And(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression AndAlso(Expression left, Expression right);
        public static BinaryExpression AndAlso(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression AndAssign(Expression left, Expression right);
        public static BinaryExpression AndAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression AndAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static IndexExpression ArrayAccess(Expression array, params Expression[] indexes);
        public static IndexExpression ArrayAccess(Expression array, IEnumerable`1<Expression> indexes);
        public static BinaryExpression ArrayIndex(Expression array, Expression index);
        public static MethodCallExpression ArrayIndex(Expression array, params Expression[] indexes);
        public static MethodCallExpression ArrayIndex(Expression array, IEnumerable`1<Expression> indexes);
        public static UnaryExpression ArrayLength(Expression array);
        public static BinaryExpression Assign(Expression left, Expression right);
        public static MemberAssignment Bind(MemberInfo member, Expression expression);
        public static MemberAssignment Bind(MethodInfo propertyAccessor, Expression expression);
        public static BlockExpression Block(Expression arg0, Expression arg1);
        public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2);
        public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2, Expression arg3);
        public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4);
        public static BlockExpression Block(params Expression[] expressions);
        public static BlockExpression Block(IEnumerable`1<Expression> expressions);
        public static BlockExpression Block(IEnumerable`1<ParameterExpression> variables, params Expression[] expressions);
        public static BlockExpression Block(IEnumerable`1<ParameterExpression> variables, IEnumerable`1<Expression> expressions);
        public static BlockExpression Block(Type type, params Expression[] expressions);
        public static BlockExpression Block(Type type, IEnumerable`1<Expression> expressions);
        public static BlockExpression Block(Type type, IEnumerable`1<ParameterExpression> variables, params Expression[] expressions);
        public static BlockExpression Block(Type type, IEnumerable`1<ParameterExpression> variables, IEnumerable`1<Expression> expressions);
        public static GotoExpression Break(LabelTarget target);
        public static GotoExpression Break(LabelTarget target, Expression value);
        public static GotoExpression Break(LabelTarget target, Expression value, Type type);
        public static GotoExpression Break(LabelTarget target, Type type);
        public static MethodCallExpression Call(Expression instance, MethodInfo method);
        public static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0, Expression arg1);
        public static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0, Expression arg1, Expression arg2);
        public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments);
        public static MethodCallExpression Call(Expression instance, MethodInfo method, IEnumerable`1<Expression> arguments);
        public static MethodCallExpression Call(Expression instance, string methodName, Type[] typeArguments, params Expression[] arguments);
        public static MethodCallExpression Call(MethodInfo method, Expression arg0);
        public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1);
        public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2);
        public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2, Expression arg3);
        public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4);
        public static MethodCallExpression Call(MethodInfo method, params Expression[] arguments);
        public static MethodCallExpression Call(MethodInfo method, IEnumerable`1<Expression> arguments);
        public static MethodCallExpression Call(Type type, string methodName, Type[] typeArguments, params Expression[] arguments);
        public static CatchBlock Catch(ParameterExpression variable, Expression body);
        public static CatchBlock Catch(ParameterExpression variable, Expression body, Expression filter);
        public static CatchBlock Catch(Type type, Expression body);
        public static CatchBlock Catch(Type type, Expression body, Expression filter);
        public static DebugInfoExpression ClearDebugInfo(SymbolDocumentInfo document);
        public static BinaryExpression Coalesce(Expression left, Expression right);
        public static BinaryExpression Coalesce(Expression left, Expression right, LambdaExpression conversion);
        public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse);
        public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse, Type type);
        public static ConstantExpression Constant(object value);
        public static ConstantExpression Constant(object value, Type type);
        public static GotoExpression Continue(LabelTarget target);
        public static GotoExpression Continue(LabelTarget target, Type type);
        public static UnaryExpression Convert(Expression expression, Type type);
        public static UnaryExpression Convert(Expression expression, Type type, MethodInfo method);
        public static UnaryExpression ConvertChecked(Expression expression, Type type);
        public static UnaryExpression ConvertChecked(Expression expression, Type type, MethodInfo method);
        public static DebugInfoExpression DebugInfo(SymbolDocumentInfo document, int startLine, int startColumn, int endLine, int endColumn);
        public static UnaryExpression Decrement(Expression expression);
        public static UnaryExpression Decrement(Expression expression, MethodInfo method);
        public static DefaultExpression Default(Type type);
        public static BinaryExpression Divide(Expression left, Expression right);
        public static BinaryExpression Divide(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression DivideAssign(Expression left, Expression right);
        public static BinaryExpression DivideAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression DivideAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, Expression arg0);
        public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, Expression arg0, Expression arg1);
        public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, Expression arg0, Expression arg1, Expression arg2);
        public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, Expression arg0, Expression arg1, Expression arg2, Expression arg3);
        public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, params Expression[] arguments);
        public static DynamicExpression Dynamic(CallSiteBinder binder, Type returnType, IEnumerable`1<Expression> arguments);
        public static ElementInit ElementInit(MethodInfo addMethod, params Expression[] arguments);
        public static ElementInit ElementInit(MethodInfo addMethod, IEnumerable`1<Expression> arguments);
        public static DefaultExpression Empty();
        public static BinaryExpression Equal(Expression left, Expression right);
        public static BinaryExpression Equal(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static BinaryExpression ExclusiveOr(Expression left, Expression right);
        public static BinaryExpression ExclusiveOr(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right);
        public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static MemberExpression Field(Expression expression, FieldInfo field);
        public static MemberExpression Field(Expression expression, string fieldName);
        public static MemberExpression Field(Expression expression, Type type, string fieldName);
        public static Type GetActionType(params Type[] typeArgs);
        public static Type GetDelegateType(params Type[] typeArgs);
        public static Type GetFuncType(params Type[] typeArgs);
        public static GotoExpression Goto(LabelTarget target);
        public static GotoExpression Goto(LabelTarget target, Expression value);
        public static GotoExpression Goto(LabelTarget target, Expression value, Type type);
        public static GotoExpression Goto(LabelTarget target, Type type);
        public static BinaryExpression GreaterThan(Expression left, Expression right);
        public static BinaryExpression GreaterThan(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right);
        public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static ConditionalExpression IfThen(Expression test, Expression ifTrue);
        public static ConditionalExpression IfThenElse(Expression test, Expression ifTrue, Expression ifFalse);
        public static UnaryExpression Increment(Expression expression);
        public static UnaryExpression Increment(Expression expression, MethodInfo method);
        public static InvocationExpression Invoke(Expression expression, params Expression[] arguments);
        public static InvocationExpression Invoke(Expression expression, IEnumerable`1<Expression> arguments);
        public static UnaryExpression IsFalse(Expression expression);
        public static UnaryExpression IsFalse(Expression expression, MethodInfo method);
        public static UnaryExpression IsTrue(Expression expression);
        public static UnaryExpression IsTrue(Expression expression, MethodInfo method);
        public static LabelTarget Label();
        public static LabelExpression Label(LabelTarget target);
        public static LabelExpression Label(LabelTarget target, Expression defaultValue);
        public static LabelTarget Label(string name);
        public static LabelTarget Label(Type type);
        public static LabelTarget Label(Type type, string name);
        public static LambdaExpression Lambda(Expression body, bool tailCall, IEnumerable`1<ParameterExpression> parameters);
        public static Expression`1<TDelegate> Lambda<TDelegate>(Expression body, bool tailCall, IEnumerable`1<ParameterExpression> parameters);
        public static LambdaExpression Lambda(Expression body, bool tailCall, params ParameterExpression[] parameters);
        public static Expression`1<TDelegate> Lambda<TDelegate>(Expression body, bool tailCall, params ParameterExpression[] parameters);
        public static LambdaExpression Lambda(Expression body, IEnumerable`1<ParameterExpression> parameters);
        public static Expression`1<TDelegate> Lambda<TDelegate>(Expression body, IEnumerable`1<ParameterExpression> parameters);
        public static Expression`1<TDelegate> Lambda<TDelegate>(Expression body, params ParameterExpression[] parameters);
        public static LambdaExpression Lambda(Expression body, params ParameterExpression[] parameters);
        public static Expression`1<TDelegate> Lambda<TDelegate>(Expression body, string name, bool tailCall, IEnumerable`1<ParameterExpression> parameters);
        public static LambdaExpression Lambda(Expression body, string name, bool tailCall, IEnumerable`1<ParameterExpression> parameters);
        public static Expression`1<TDelegate> Lambda<TDelegate>(Expression body, string name, IEnumerable`1<ParameterExpression> parameters);
        public static LambdaExpression Lambda(Expression body, string name, IEnumerable`1<ParameterExpression> parameters);
        public static LambdaExpression Lambda(Type delegateType, Expression body, bool tailCall, IEnumerable`1<ParameterExpression> parameters);
        public static LambdaExpression Lambda(Type delegateType, Expression body, bool tailCall, params ParameterExpression[] parameters);
        public static LambdaExpression Lambda(Type delegateType, Expression body, IEnumerable`1<ParameterExpression> parameters);
        public static LambdaExpression Lambda(Type delegateType, Expression body, params ParameterExpression[] parameters);
        public static LambdaExpression Lambda(Type delegateType, Expression body, string name, bool tailCall, IEnumerable`1<ParameterExpression> parameters);
        public static LambdaExpression Lambda(Type delegateType, Expression body, string name, IEnumerable`1<ParameterExpression> parameters);
        public static BinaryExpression LeftShift(Expression left, Expression right);
        public static BinaryExpression LeftShift(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression LeftShiftAssign(Expression left, Expression right);
        public static BinaryExpression LeftShiftAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression LeftShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression LessThan(Expression left, Expression right);
        public static BinaryExpression LessThan(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static BinaryExpression LessThanOrEqual(Expression left, Expression right);
        public static BinaryExpression LessThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static MemberListBinding ListBind(MemberInfo member, params ElementInit[] initializers);
        public static MemberListBinding ListBind(MemberInfo member, IEnumerable`1<ElementInit> initializers);
        public static MemberListBinding ListBind(MethodInfo propertyAccessor, params ElementInit[] initializers);
        public static MemberListBinding ListBind(MethodInfo propertyAccessor, IEnumerable`1<ElementInit> initializers);
        public static ListInitExpression ListInit(NewExpression newExpression, params ElementInit[] initializers);
        public static ListInitExpression ListInit(NewExpression newExpression, params Expression[] initializers);
        public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable`1<ElementInit> initializers);
        public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable`1<Expression> initializers);
        public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, params Expression[] initializers);
        public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable`1<Expression> initializers);
        public static LoopExpression Loop(Expression body);
        public static LoopExpression Loop(Expression body, LabelTarget break);
        public static LoopExpression Loop(Expression body, LabelTarget break, LabelTarget continue);
        public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right);
        public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method, LambdaExpression conversion);
        public static CatchBlock MakeCatchBlock(Type type, ParameterExpression variable, Expression body, Expression filter);
        public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, Expression arg0);
        public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1);
        public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2);
        public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, Expression arg0, Expression arg1, Expression arg2, Expression arg3);
        public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, params Expression[] arguments);
        public static DynamicExpression MakeDynamic(Type delegateType, CallSiteBinder binder, IEnumerable`1<Expression> arguments);
        public static GotoExpression MakeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type type);
        public static IndexExpression MakeIndex(Expression instance, PropertyInfo indexer, IEnumerable`1<Expression> arguments);
        public static MemberExpression MakeMemberAccess(Expression expression, MemberInfo member);
        public static TryExpression MakeTry(Type type, Expression body, Expression finally, Expression fault, IEnumerable`1<CatchBlock> handlers);
        public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type);
        public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type, MethodInfo method);
        public static MemberMemberBinding MemberBind(MemberInfo member, IEnumerable`1<MemberBinding> bindings);
        public static MemberMemberBinding MemberBind(MemberInfo member, params MemberBinding[] bindings);
        public static MemberMemberBinding MemberBind(MethodInfo propertyAccessor, IEnumerable`1<MemberBinding> bindings);
        public static MemberMemberBinding MemberBind(MethodInfo propertyAccessor, params MemberBinding[] bindings);
        public static MemberInitExpression MemberInit(NewExpression newExpression, IEnumerable`1<MemberBinding> bindings);
        public static MemberInitExpression MemberInit(NewExpression newExpression, params MemberBinding[] bindings);
        public static BinaryExpression Modulo(Expression left, Expression right);
        public static BinaryExpression Modulo(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression ModuloAssign(Expression left, Expression right);
        public static BinaryExpression ModuloAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression ModuloAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression Multiply(Expression left, Expression right);
        public static BinaryExpression Multiply(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression MultiplyAssign(Expression left, Expression right);
        public static BinaryExpression MultiplyAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression MultiplyAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right);
        public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression MultiplyChecked(Expression left, Expression right);
        public static BinaryExpression MultiplyChecked(Expression left, Expression right, MethodInfo method);
        public static UnaryExpression Negate(Expression expression);
        public static UnaryExpression Negate(Expression expression, MethodInfo method);
        public static UnaryExpression NegateChecked(Expression expression);
        public static UnaryExpression NegateChecked(Expression expression, MethodInfo method);
        public static NewExpression New(ConstructorInfo constructor);
        public static NewExpression New(ConstructorInfo constructor, params Expression[] arguments);
        public static NewExpression New(ConstructorInfo constructor, IEnumerable`1<Expression> arguments);
        public static NewExpression New(ConstructorInfo constructor, IEnumerable`1<Expression> arguments, IEnumerable`1<MemberInfo> members);
        public static NewExpression New(ConstructorInfo constructor, IEnumerable`1<Expression> arguments, params MemberInfo[] members);
        public static NewExpression New(Type type);
        public static NewArrayExpression NewArrayBounds(Type type, params Expression[] bounds);
        public static NewArrayExpression NewArrayBounds(Type type, IEnumerable`1<Expression> bounds);
        public static NewArrayExpression NewArrayInit(Type type, params Expression[] initializers);
        public static NewArrayExpression NewArrayInit(Type type, IEnumerable`1<Expression> initializers);
        public static UnaryExpression Not(Expression expression);
        public static UnaryExpression Not(Expression expression, MethodInfo method);
        public static BinaryExpression NotEqual(Expression left, Expression right);
        public static BinaryExpression NotEqual(Expression left, Expression right, bool liftToNull, MethodInfo method);
        public static UnaryExpression OnesComplement(Expression expression);
        public static UnaryExpression OnesComplement(Expression expression, MethodInfo method);
        public static BinaryExpression Or(Expression left, Expression right);
        public static BinaryExpression Or(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression OrAssign(Expression left, Expression right);
        public static BinaryExpression OrAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression OrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression OrElse(Expression left, Expression right);
        public static BinaryExpression OrElse(Expression left, Expression right, MethodInfo method);
        public static ParameterExpression Parameter(Type type);
        public static ParameterExpression Parameter(Type type, string name);
        public static UnaryExpression PostDecrementAssign(Expression expression);
        public static UnaryExpression PostDecrementAssign(Expression expression, MethodInfo method);
        public static UnaryExpression PostIncrementAssign(Expression expression);
        public static UnaryExpression PostIncrementAssign(Expression expression, MethodInfo method);
        public static BinaryExpression Power(Expression left, Expression right);
        public static BinaryExpression Power(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression PowerAssign(Expression left, Expression right);
        public static BinaryExpression PowerAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression PowerAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static UnaryExpression PreDecrementAssign(Expression expression);
        public static UnaryExpression PreDecrementAssign(Expression expression, MethodInfo method);
        public static UnaryExpression PreIncrementAssign(Expression expression);
        public static UnaryExpression PreIncrementAssign(Expression expression, MethodInfo method);
        public static MemberExpression Property(Expression expression, MethodInfo propertyAccessor);
        public static MemberExpression Property(Expression expression, PropertyInfo property);
        public static IndexExpression Property(Expression instance, PropertyInfo indexer, params Expression[] arguments);
        public static IndexExpression Property(Expression instance, PropertyInfo indexer, IEnumerable`1<Expression> arguments);
        public static MemberExpression Property(Expression expression, string propertyName);
        public static IndexExpression Property(Expression instance, string propertyName, params Expression[] arguments);
        public static MemberExpression Property(Expression expression, Type type, string propertyName);
        public static MemberExpression PropertyOrField(Expression expression, string propertyOrFieldName);
        public static UnaryExpression Quote(Expression expression);
        public virtual Expression Reduce();
        public Expression ReduceAndCheck();
        public Expression ReduceExtensions();
        public static BinaryExpression ReferenceEqual(Expression left, Expression right);
        public static BinaryExpression ReferenceNotEqual(Expression left, Expression right);
        public static UnaryExpression Rethrow();
        public static UnaryExpression Rethrow(Type type);
        public static GotoExpression Return(LabelTarget target);
        public static GotoExpression Return(LabelTarget target, Expression value);
        public static GotoExpression Return(LabelTarget target, Expression value, Type type);
        public static GotoExpression Return(LabelTarget target, Type type);
        public static BinaryExpression RightShift(Expression left, Expression right);
        public static BinaryExpression RightShift(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression RightShiftAssign(Expression left, Expression right);
        public static BinaryExpression RightShiftAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression RightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static RuntimeVariablesExpression RuntimeVariables(IEnumerable`1<ParameterExpression> variables);
        public static RuntimeVariablesExpression RuntimeVariables(params ParameterExpression[] variables);
        public static BinaryExpression Subtract(Expression left, Expression right);
        public static BinaryExpression Subtract(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression SubtractAssign(Expression left, Expression right);
        public static BinaryExpression SubtractAssign(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression SubtractAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression SubtractAssignChecked(Expression left, Expression right);
        public static BinaryExpression SubtractAssignChecked(Expression left, Expression right, MethodInfo method);
        public static BinaryExpression SubtractAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
        public static BinaryExpression SubtractChecked(Expression left, Expression right);
        public static BinaryExpression SubtractChecked(Expression left, Expression right, MethodInfo method);
        public static SwitchExpression Switch(Expression switchValue, Expression defaultBody, MethodInfo comparison, IEnumerable`1<SwitchCase> cases);
        public static SwitchExpression Switch(Expression switchValue, Expression defaultBody, MethodInfo comparison, params SwitchCase[] cases);
        public static SwitchExpression Switch(Expression switchValue, Expression defaultBody, params SwitchCase[] cases);
        public static SwitchExpression Switch(Expression switchValue, params SwitchCase[] cases);
        public static SwitchExpression Switch(Type type, Expression switchValue, Expression defaultBody, MethodInfo comparison, IEnumerable`1<SwitchCase> cases);
        public static SwitchExpression Switch(Type type, Expression switchValue, Expression defaultBody, MethodInfo comparison, params SwitchCase[] cases);
        public static SwitchCase SwitchCase(Expression body, params Expression[] testValues);
        public static SwitchCase SwitchCase(Expression body, IEnumerable`1<Expression> testValues);
        public static SymbolDocumentInfo SymbolDocument(string fileName);
        public static SymbolDocumentInfo SymbolDocument(string fileName, Guid language);
        public static SymbolDocumentInfo SymbolDocument(string fileName, Guid language, Guid languageVendor);
        public static SymbolDocumentInfo SymbolDocument(string fileName, Guid language, Guid languageVendor, Guid documentType);
        public static UnaryExpression Throw(Expression value);
        public static UnaryExpression Throw(Expression value, Type type);
        public override string ToString();
        public static TryExpression TryCatch(Expression body, params CatchBlock[] handlers);
        public static TryExpression TryCatchFinally(Expression body, Expression finally, params CatchBlock[] handlers);
        public static TryExpression TryFault(Expression body, Expression fault);
        public static TryExpression TryFinally(Expression body, Expression finally);
        public static bool TryGetActionType(Type[] typeArgs, ref Type actionType);
        public static bool TryGetFuncType(Type[] typeArgs, ref Type funcType);
        public static UnaryExpression TypeAs(Expression expression, Type type);
        public static TypeBinaryExpression TypeEqual(Expression expression, Type type);
        public static TypeBinaryExpression TypeIs(Expression expression, Type type);
        public static UnaryExpression UnaryPlus(Expression expression);
        public static UnaryExpression UnaryPlus(Expression expression, MethodInfo method);
        public static UnaryExpression Unbox(Expression expression, Type type);
        public static ParameterExpression Variable(Type type);
        public static ParameterExpression Variable(Type type, string name);
        protected virtual Expression VisitChildren(ExpressionVisitor visitor);
    }

    public sealed class Expression`1<TDelegate>: LambdaExpression
    {
        protected override Expression Accept(ExpressionVisitor visitor);
        public TDelegate Compile();
        public TDelegate Compile(DebugInfoGenerator debugInfoGenerator);
        public Expression`1<TDelegate> Update(Expression body, IEnumerable`1<ParameterExpression> parameters);
    }

    public abstract class ExpressionVisitor
    {
        protected ExpressionVisitor();
        public virtual Expression Visit(Expression node);
        public ReadOnlyCollection`1<Expression> Visit(ReadOnlyCollection`1<Expression> nodes);
        public static ReadOnlyCollection`1<T> Visit<T>(ReadOnlyCollection`1<T> nodes, Func`2<T,T> elementVisitor);
        public ReadOnlyCollection`1<T> VisitAndConvert<T>(ReadOnlyCollection`1<T> nodes, string callerName);
        public T VisitAndConvert<T>(T node, string callerName);
        protected virtual Expression VisitBinary(BinaryExpression node);
        protected virtual Expression VisitBlock(BlockExpression node);
        protected virtual CatchBlock VisitCatchBlock(CatchBlock node);
        protected virtual Expression VisitConditional(ConditionalExpression node);
        protected virtual Expression VisitConstant(ConstantExpression node);
        protected virtual Expression VisitDebugInfo(DebugInfoExpression node);
        protected virtual Expression VisitDefault(DefaultExpression node);
        protected virtual Expression VisitDynamic(DynamicExpression node);
        protected virtual ElementInit VisitElementInit(ElementInit node);
        protected virtual Expression VisitExtension(Expression node);
        protected virtual Expression VisitGoto(GotoExpression node);
        protected virtual Expression VisitIndex(IndexExpression node);
        protected virtual Expression VisitInvocation(InvocationExpression node);
        protected virtual Expression VisitLabel(LabelExpression node);
        protected virtual LabelTarget VisitLabelTarget(LabelTarget node);
        protected virtual Expression VisitLambda<T>(Expression`1<T> node);
        protected virtual Expression VisitListInit(ListInitExpression node);
        protected virtual Expression VisitLoop(LoopExpression node);
        protected virtual Expression VisitMember(MemberExpression node);
        protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment node);
        protected virtual MemberBinding VisitMemberBinding(MemberBinding node);
        protected virtual Expression VisitMemberInit(MemberInitExpression node);
        protected virtual MemberListBinding VisitMemberListBinding(MemberListBinding node);
        protected virtual MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding node);
        protected virtual Expression VisitMethodCall(MethodCallExpression node);
        protected virtual Expression VisitNew(NewExpression node);
        protected virtual Expression VisitNewArray(NewArrayExpression node);
        protected virtual Expression VisitParameter(ParameterExpression node);
        protected virtual Expression VisitRuntimeVariables(RuntimeVariablesExpression node);
        protected virtual Expression VisitSwitch(SwitchExpression node);
        protected virtual SwitchCase VisitSwitchCase(SwitchCase node);
        protected virtual Expression VisitTry(TryExpression node);
        protected virtual Expression VisitTypeBinary(TypeBinaryExpression node);
        protected virtual Expression VisitUnary(UnaryExpression node);
    }

    public sealed class GotoExpression: Expression
    {
        public GotoExpressionKind Kind { get; }
        public LabelTarget Target { get; }
        public Expression Value { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public GotoExpression Update(LabelTarget target, Expression value);
    }

    public sealed class IndexExpression: Expression
    {
        public ReadOnlyCollection`1<Expression> Arguments { get; }
        public PropertyInfo Indexer { get; }
        public Expression Object { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public IndexExpression Update(Expression object, IEnumerable`1<Expression> arguments);
    }

    public sealed class InvocationExpression: Expression
    {
        public ReadOnlyCollection`1<Expression> Arguments { get; }
        public Expression Expression { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public InvocationExpression Update(Expression expression, IEnumerable`1<Expression> arguments);
    }

    public sealed class LabelExpression: Expression
    {
        public Expression DefaultValue { get; }
        public LabelTarget Target { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public LabelExpression Update(LabelTarget target, Expression defaultValue);
    }

    public sealed class LabelTarget
    {
        public string Name { get; }
        public Type Type { get; }
        public override string ToString();
    }

    public abstract class LambdaExpression: Expression
    {
        public Expression Body { get; }
        public string Name { get; }
        public ReadOnlyCollection`1<ParameterExpression> Parameters { get; }
        public Type ReturnType { get; }
        public bool TailCall { get; }
        public Delegate Compile();
        public Delegate Compile(DebugInfoGenerator debugInfoGenerator);
        public void CompileToMethod(MethodBuilder method);
        public void CompileToMethod(MethodBuilder method, DebugInfoGenerator debugInfoGenerator);
    }

    public sealed class ListInitExpression: Expression
    {
        public ReadOnlyCollection`1<ElementInit> Initializers { get; }
        public NewExpression NewExpression { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public override Expression Reduce();
        public ListInitExpression Update(NewExpression newExpression, IEnumerable`1<ElementInit> initializers);
    }

    public sealed class LoopExpression: Expression
    {
        public Expression Body { get; }
        public LabelTarget BreakLabel { get; }
        public LabelTarget ContinueLabel { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public LoopExpression Update(LabelTarget breakLabel, LabelTarget continueLabel, Expression body);
    }

    public sealed class MemberAssignment: MemberBinding
    {
        public Expression Expression { get; }
        public MemberAssignment Update(Expression expression);
    }

    public abstract class MemberBinding
    {
        protected MemberBinding(MemberBindingType type, MemberInfo member);
        public MemberBindingType BindingType { get; }
        public MemberInfo Member { get; }
        public override string ToString();
    }

    public class MemberExpression: Expression
    {
        public Expression Expression { get; }
        public MemberInfo Member { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public MemberExpression Update(Expression expression);
    }

    public sealed class MemberInitExpression: Expression
    {
        public ReadOnlyCollection`1<MemberBinding> Bindings { get; }
        public NewExpression NewExpression { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public override Expression Reduce();
        public MemberInitExpression Update(NewExpression newExpression, IEnumerable`1<MemberBinding> bindings);
    }

    public sealed class MemberListBinding: MemberBinding
    {
        public ReadOnlyCollection`1<ElementInit> Initializers { get; }
        public MemberListBinding Update(IEnumerable`1<ElementInit> initializers);
    }

    public sealed class MemberMemberBinding: MemberBinding
    {
        public ReadOnlyCollection`1<MemberBinding> Bindings { get; }
        public MemberMemberBinding Update(IEnumerable`1<MemberBinding> bindings);
    }

    public class MethodCallExpression: Expression
    {
        public ReadOnlyCollection`1<Expression> Arguments { get; }
        public MethodInfo Method { get; }
        public Expression Object { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public MethodCallExpression Update(Expression object, IEnumerable`1<Expression> arguments);
    }

    public class NewArrayExpression: Expression
    {
        public ReadOnlyCollection`1<Expression> Expressions { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public NewArrayExpression Update(IEnumerable`1<Expression> expressions);
    }

    public class NewExpression: Expression
    {
        public ReadOnlyCollection`1<Expression> Arguments { get; }
        public ConstructorInfo Constructor { get; }
        public ReadOnlyCollection`1<MemberInfo> Members { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public NewExpression Update(IEnumerable`1<Expression> arguments);
    }

    public class ParameterExpression: Expression
    {
        public bool IsByRef { get; }
        public string Name { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
    }

    public sealed class RuntimeVariablesExpression: Expression
    {
        public ReadOnlyCollection`1<ParameterExpression> Variables { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public RuntimeVariablesExpression Update(IEnumerable`1<ParameterExpression> variables);
    }

    public sealed class SwitchCase
    {
        public Expression Body { get; }
        public ReadOnlyCollection`1<Expression> TestValues { get; }
        public override string ToString();
        public SwitchCase Update(IEnumerable`1<Expression> testValues, Expression body);
    }

    public sealed class SwitchExpression: Expression
    {
        public ReadOnlyCollection`1<SwitchCase> Cases { get; }
        public MethodInfo Comparison { get; }
        public Expression DefaultBody { get; }
        public Expression SwitchValue { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public SwitchExpression Update(Expression switchValue, IEnumerable`1<SwitchCase> cases, Expression defaultBody);
    }

    public class SymbolDocumentInfo
    {
        public virtual Guid DocumentType { get; }
        public string FileName { get; }
        public virtual Guid Language { get; }
        public virtual Guid LanguageVendor { get; }
    }

    public sealed class TryExpression: Expression
    {
        public Expression Body { get; }
        public Expression Fault { get; }
        public Expression Finally { get; }
        public ReadOnlyCollection`1<CatchBlock> Handlers { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public TryExpression Update(Expression body, IEnumerable`1<CatchBlock> handlers, Expression finally, Expression fault);
    }

    public sealed class TypeBinaryExpression: Expression
    {
        public Expression Expression { get; }
        public Type TypeOperand { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public TypeBinaryExpression Update(Expression expression);
    }

    public sealed class UnaryExpression: Expression
    {
        public bool IsLifted { get; }
        public bool IsLiftedToNull { get; }
        public MethodInfo Method { get; }
        public Expression Operand { get; }
        protected override Expression Accept(ExpressionVisitor visitor);
        public override Expression Reduce();
        public UnaryExpression Update(Expression operand);
    }

    public enum ExpressionType
    {
        Add,
        AddAssign,
        AddAssignChecked,
        AddChecked,
        And,
        AndAlso,
        AndAssign,
        ArrayIndex,
        ArrayLength,
        Assign,
        Block,
        Call,
        Coalesce,
        Conditional,
        Constant,
        Convert,
        ConvertChecked,
        DebugInfo,
        Decrement,
        Default,
        Divide,
        DivideAssign,
        Dynamic,
        Equal,
        ExclusiveOr,
        ExclusiveOrAssign,
        Extension,
        Goto,
        GreaterThan,
        GreaterThanOrEqual,
        Increment,
        Index,
        Invoke,
        IsFalse,
        IsTrue,
        Label,
        Lambda,
        LeftShift,
        LeftShiftAssign,
        LessThan,
        LessThanOrEqual,
        ListInit,
        Loop,
        MemberAccess,
        MemberInit,
        Modulo,
        ModuloAssign,
        Multiply,
        MultiplyAssign,
        MultiplyAssignChecked,
        MultiplyChecked,
        Negate,
        NegateChecked,
        New,
        NewArrayBounds,
        NewArrayInit,
        Not,
        NotEqual,
        OnesComplement,
        Or,
        OrAssign,
        OrElse,
        Parameter,
        PostDecrementAssign,
        PostIncrementAssign,
        Power,
        PowerAssign,
        PreDecrementAssign,
        PreIncrementAssign,
        Quote,
        RightShift,
        RightShiftAssign,
        RuntimeVariables,
        Subtract,
        SubtractAssign,
        SubtractAssignChecked,
        SubtractChecked,
        Switch,
        Throw,
        Try,
        TypeAs,
        TypeEqual,
        TypeIs,
        UnaryPlus,
        Unbox,
    }

    public enum GotoExpressionKind
    {
        Break,
        Continue,
        Goto,
        Return,
    }

    public enum MemberBindingType
    {
        Assignment,
        ListBinding,
        MemberBinding,
    }

} 

namespace System.Runtime.CompilerServices
{
    public class CallSite
    {
        public CallSiteBinder Binder { get; }
        public static CallSite Create(Type delegateType, CallSiteBinder binder);
    }

    public sealed class CallSite`1<T>: CallSite
    {
        public T Target;
        public T Update { get; }
        public static CallSite`1<T> Create(CallSiteBinder binder);
    }

    public abstract class CallSiteBinder
    {
        protected CallSiteBinder();
        public static LabelTarget UpdateLabel { get; }
        public abstract Expression Bind(object[] args, ReadOnlyCollection`1<ParameterExpression> parameters, LabelTarget returnLabel);
        public virtual T BindDelegate<T>(CallSite`1<T> site, object[] args);
        protected void CacheTarget<T>(T target);
    }

    public abstract sealed class CallSiteHelpers
    {
        public static bool IsInternalFrame(MethodBase mb);
    }

    [DebuggerStepThroughAttribute(..)]
    [EditorBrowsableAttribute(..)]
    public abstract sealed class CallSiteOps
    {
        public static void AddRule<T>(CallSite`1<T> site, T rule);
        public static T Bind<T>(CallSiteBinder binder, CallSite`1<T> site, object[] args);
        public static void ClearMatch(CallSite site);
        public static CallSite`1<T> CreateMatchmaker<T>(CallSite`1<T> site);
        public static T[] GetCachedRules<T>(RuleCache`1<T> cache);
        public static bool GetMatch(CallSite site);
        public static RuleCache`1<T> GetRuleCache<T>(CallSite`1<T> site);
        public static T[] GetRules<T>(CallSite`1<T> site);
        public static void MoveRule<T>(RuleCache`1<T> cache, T rule, int i);
        public static bool SetNotMatched(CallSite site);
        public static void UpdateRules<T>(CallSite`1<T> this, int matched);
    }

    [DebuggerStepThroughAttribute(..)]
    [EditorBrowsableAttribute(..)]
    public sealed class Closure
    {
        public Closure(object[] constants, object[] locals);
        public readonly object[] Constants;
        public readonly object[] Locals;
    }

    public abstract class DebugInfoGenerator
    {
        protected DebugInfoGenerator();
        public static DebugInfoGenerator CreatePdbGenerator();
        public abstract void MarkSequencePoint(LambdaExpression method, int ilOffset, DebugInfoExpression sequencePoint);
    }

    [DefaultMemberAttribute(..)]
    public interface IRuntimeVariables
    {
        public int Count { get; }
        public object this[int index] { get; set; }
    }

    public interface IStrongBox
    {
        public object Value { get; set; }
    }

    [DebuggerStepThroughAttribute(..)]
    [EditorBrowsableAttribute(..)]
    public class RuleCache`1<T>
    {
    }

    [DebuggerStepThroughAttribute(..)]
    [EditorBrowsableAttribute(..)]
    public abstract sealed class RuntimeOps
    {
        public static IRuntimeVariables CreateRuntimeVariables();
        public static IRuntimeVariables CreateRuntimeVariables(object[] data, long[] indexes);
        public static bool ExpandoCheckVersion(ExpandoObject expando, object version);
        public static void ExpandoPromoteClass(ExpandoObject expando, object oldClass, object newClass);
        public static bool ExpandoTryDeleteValue(ExpandoObject expando, object indexClass, int index, string name, bool ignoreCase);
        public static bool ExpandoTryGetValue(ExpandoObject expando, object indexClass, int index, string name, bool ignoreCase, ref object value);
        public static object ExpandoTrySetValue(ExpandoObject expando, object indexClass, int index, object value, string name, bool ignoreCase);
        public static IRuntimeVariables MergeRuntimeVariables(IRuntimeVariables first, IRuntimeVariables second, int[] indexes);
        public static Expression Quote(Expression expression, object hoistedLocals, object[] locals);
    }

    public class StrongBox`1<T>: IStrongBox
    {
        public StrongBox`1();
        public StrongBox`1(T value);
        public T Value;
    }

    [DefaultMemberAttribute(..)]
    public sealed class ReadOnlyCollectionBuilder`1<T>: IList, IList`1<T>
    {
        public ReadOnlyCollectionBuilder`1();
        public ReadOnlyCollectionBuilder`1(IEnumerable`1<T> collection);
        public ReadOnlyCollectionBuilder`1(int capacity);
        public int Capacity { get; set; }
        public int Count { get; }
        public T this[int index] { get; set; }
        public void Add(T item);
        public void Clear();
        public bool Contains(T item);
        public void CopyTo(T[] array, int arrayIndex);
        public IEnumerator`1<T> GetEnumerator();
        public int IndexOf(T item);
        public void Insert(int index, T item);
        public bool Remove(T item);
        public void RemoveAt(int index);
        public void Reverse();
        public void Reverse(int index, int count);
        public T[] ToArray();
        public ReadOnlyCollection`1<T> ToReadOnlyCollection();
    }

    [AttributeUsageAttribute(..)]
    public sealed class DynamicAttribute: Attribute, _Attribute
    {
        public DynamicAttribute();
        public DynamicAttribute(bool[] transformFlags);
        public IList`1<bool> TransformFlags { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class ExtensionAttribute: Attribute, _Attribute
    {
        public ExtensionAttribute();
    }

} 

namespace System
{
    public class FileStyleUriParser: UriParser
    {
        public FileStyleUriParser();
    }

    public class FtpStyleUriParser: UriParser
    {
        public FtpStyleUriParser();
    }

    public class GenericUriParser: UriParser
    {
        public GenericUriParser(GenericUriParserOptions options);
    }

    public class HttpStyleUriParser: UriParser
    {
        public HttpStyleUriParser();
    }

    [TypeConverterAttribute(..)]
    public class Uri
    {
        public Uri(string uriString);
        public Uri(string uriString, UriKind uriKind);
        public Uri(Uri baseUri, string relativeUri);
        public Uri(Uri baseUri, Uri relativeUri);
        public static readonly string SchemeDelimiter;
        public static readonly string UriSchemeFile;
        public static readonly string UriSchemeFtp;
        public static readonly string UriSchemeGopher;
        public static readonly string UriSchemeHttp;
        public static readonly string UriSchemeHttps;
        public static readonly string UriSchemeMailto;
        public static readonly string UriSchemeNetPipe;
        public static readonly string UriSchemeNetTcp;
        public static readonly string UriSchemeNews;
        public static readonly string UriSchemeNntp;
        public string AbsolutePath { get; }
        public string AbsoluteUri { get; }
        public string DnsSafeHost { get; }
        public string Fragment { get; }
        public string Host { get; }
        public bool IsAbsoluteUri { get; }
        public bool IsUnc { get; }
        public string LocalPath { get; }
        public string OriginalString { get; }
        public int Port { get; }
        public string Query { get; }
        public string Scheme { get; }
        public bool UserEscaped { get; }
        public string UserInfo { get; }
        public static bool CheckSchemeName(string schemeName);
        public static int Compare(Uri uri1, Uri uri2, UriComponents partsToCompare, UriFormat compareFormat, StringComparison comparisonType);
        public override bool Equals(object comparand);
        public static string EscapeDataString(string stringToEscape);
        public static string EscapeUriString(string stringToEscape);
        public static int FromHex(char digit);
        public string GetComponents(UriComponents components, UriFormat format);
        public override int GetHashCode();
        public bool IsBaseOf(Uri uri);
        public static bool IsHexDigit(char character);
        public static bool IsWellFormedUriString(string uriString, UriKind uriKind);
        public Uri MakeRelativeUri(Uri uri);
        public override string ToString();
        public static bool TryCreate(string uriString, UriKind uriKind, ref Uri result);
        public static bool TryCreate(Uri baseUri, string relativeUri, ref Uri result);
        public static bool TryCreate(Uri baseUri, Uri relativeUri, ref Uri result);
        public static string UnescapeDataString(string stringToUnescape);
        public static bool operator ==(Uri uri1, Uri uri2);
        public static bool operator !=(Uri uri1, Uri uri2);
    }

    public class UriBuilder
    {
        public UriBuilder();
        public UriBuilder(string uri);
        public UriBuilder(string schemeName, string hostName);
        public UriBuilder(string scheme, string host, int portNumber);
        public UriBuilder(string scheme, string host, int port, string pathValue);
        public UriBuilder(string scheme, string host, int port, string path, string extraValue);
        public UriBuilder(Uri uri);
        public string Fragment { get; set; }
        public string Host { get; set; }
        public string Password { get; set; }
        public string Path { get; set; }
        public int Port { get; set; }
        public string Query { get; set; }
        public string Scheme { get; set; }
        public Uri Uri { get; }
        public string UserName { get; set; }
        public override bool Equals(object rparam);
        public override int GetHashCode();
        public override string ToString();
    }

    public abstract class UriParser
    {
        protected UriParser();
        protected virtual string GetComponents(Uri uri, UriComponents components, UriFormat format);
        protected virtual void InitializeAndValidate(Uri uri, ref UriFormatException parsingError);
        protected virtual bool IsBaseOf(Uri baseUri, Uri relativeUri);
        public static bool IsKnownScheme(string schemeName);
        protected virtual bool IsWellFormedOriginalString(Uri uri);
        protected virtual UriParser OnNewUri();
        protected virtual void OnRegister(string schemeName, int defaultPort);
        public static void Register(UriParser uriParser, string schemeName, int defaultPort);
        protected virtual string Resolve(Uri baseUri, Uri relativeUri, ref UriFormatException parsingError);
    }

    public sealed class UriTypeConverter: TypeConverter
    {
        public UriTypeConverter();
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
    }

    [FlagsAttribute(..)]
    public enum GenericUriParserOptions
    {
        AllowEmptyAuthority,
        Default,
        DontCompressPath,
        DontConvertPathBackslashes,
        DontUnescapePathDotsAndSlashes,
        GenericAuthority,
        Idn,
        IriParsing,
        NoFragment,
        NoPort,
        NoQuery,
        NoUserInfo,
    }

    [FlagsAttribute(..)]
    public enum UriComponents
    {
        AbsoluteUri,
        Fragment,
        Host,
        HostAndPort,
        HttpRequestUrl,
        KeepDelimiter,
        Path,
        PathAndQuery,
        Port,
        Query,
        Scheme,
        SchemeAndServer,
        SerializationInfoString,
        StrongAuthority,
        StrongPort,
        UserInfo,
    }

    public enum UriFormat
    {
        SafeUnescaped,
        Unescaped,
        UriEscaped,
    }

    public enum UriIdnScope
    {
        All,
        AllExceptIntranet,
        None,
    }

    public enum UriKind
    {
        Absolute,
        Relative,
        RelativeOrAbsolute,
    }

    public class UriFormatException: FormatException, _Exception, ISerializable
    {
        public UriFormatException();
        public UriFormatException(string textString);
        public UriFormatException(string textString, Exception e);
    }

} 

namespace System.CodeDom.Compiler
{
    [AttributeUsageAttribute(..)]
    public sealed class GeneratedCodeAttribute: Attribute, _Attribute
    {
        public GeneratedCodeAttribute(string tool, string version);
        public string Tool { get; }
        public string Version { get; }
    }

} 

namespace System.Collections.Generic
{
    [ComVisibleAttribute(..)]
    public sealed class LinkedListNode`1<T>
    {
        public LinkedListNode`1(T value);
        public LinkedList`1<T> List { get; }
        public LinkedListNode`1<T> Next { get; }
        public LinkedListNode`1<T> Previous { get; }
        public T Value { get; set; }
    }

    public interface ISet`1<T>: ICollection`1<T>
    {
        public bool Add(T item);
        public void ExceptWith(IEnumerable`1<T> other);
        public void IntersectWith(IEnumerable`1<T> other);
        public bool IsProperSubsetOf(IEnumerable`1<T> other);
        public bool IsProperSupersetOf(IEnumerable`1<T> other);
        public bool IsSubsetOf(IEnumerable`1<T> other);
        public bool IsSupersetOf(IEnumerable`1<T> other);
        public bool Overlaps(IEnumerable`1<T> other);
        public bool SetEquals(IEnumerable`1<T> other);
        public void SymmetricExceptWith(IEnumerable`1<T> other);
        public void UnionWith(IEnumerable`1<T> other);
    }

    [ComVisibleAttribute(..)]
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    public class LinkedList`1<T>: ICollection, ICollection`1<T>
    {
        public LinkedList`1();
        public LinkedList`1(IEnumerable`1<T> collection);
        public int Count { get; }
        public LinkedListNode`1<T> First { get; }
        public LinkedListNode`1<T> Last { get; }
        public void AddAfter(LinkedListNode`1<T> node, LinkedListNode`1<T> newNode);
        public LinkedListNode`1<T> AddAfter(LinkedListNode`1<T> node, T value);
        public void AddBefore(LinkedListNode`1<T> node, LinkedListNode`1<T> newNode);
        public LinkedListNode`1<T> AddBefore(LinkedListNode`1<T> node, T value);
        public void AddFirst(LinkedListNode`1<T> node);
        public LinkedListNode`1<T> AddFirst(T value);
        public void AddLast(LinkedListNode`1<T> node);
        public LinkedListNode`1<T> AddLast(T value);
        public void Clear();
        public bool Contains(T value);
        public void CopyTo(T[] array, int index);
        public LinkedListNode`1<T> Find(T value);
        public LinkedListNode`1<T> FindLast(T value);
        public Enumerator<T> GetEnumerator();
        public void Remove(LinkedListNode`1<T> node);
        public bool Remove(T value);
        public void RemoveFirst();
        public void RemoveLast();
    }

    [ComVisibleAttribute(..)]
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    public class Queue`1<T>: ICollection, IEnumerable`1<T>
    {
        public Queue`1();
        public Queue`1(IEnumerable`1<T> collection);
        public Queue`1(int capacity);
        public int Count { get; }
        public void Clear();
        public bool Contains(T item);
        public void CopyTo(T[] array, int arrayIndex);
        public T Dequeue();
        public void Enqueue(T item);
        public Enumerator<T> GetEnumerator();
        public T Peek();
        public T[] ToArray();
        public void TrimExcess();
    }

    [ComVisibleAttribute(..)]
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    public class Stack`1<T>: ICollection, IEnumerable`1<T>
    {
        public Stack`1();
        public Stack`1(IEnumerable`1<T> collection);
        public Stack`1(int capacity);
        public int Count { get; }
        public void Clear();
        public bool Contains(T item);
        public void CopyTo(T[] array, int arrayIndex);
        public Enumerator<T> GetEnumerator();
        public T Peek();
        public T Pop();
        public void Push(T item);
        public T[] ToArray();
        public void TrimExcess();
    }

} 

namespace System.ComponentModel
{
    public sealed class AsyncOperation
    {
        public SynchronizationContext SynchronizationContext { get; }
        public object UserSuppliedState { get; }
        protected override void Finalize();
        public void OperationCompleted();
        public void Post(SendOrPostCallback d, object arg);
        public void PostOperationCompleted(SendOrPostCallback d, object arg);
    }

    public abstract sealed class AsyncOperationManager
    {
        public static SynchronizationContext SynchronizationContext { get; set; }
        public static AsyncOperation CreateOperation(object userSuppliedState);
    }

    public class BackgroundWorker
    {
        public BackgroundWorker();
        public bool CancellationPending { get; }
        public bool IsBusy { get; }
        public bool WorkerReportsProgress { get; set; }
        public bool WorkerSupportsCancellation { get; set; }
        public void CancelAsync();
        protected virtual void OnDoWork(DoWorkEventArgs e);
        protected virtual void OnProgressChanged(ProgressChangedEventArgs e);
        protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e);
        public void ReportProgress(int percentProgress);
        public void ReportProgress(int percentProgress, object userState);
        public void RunWorkerAsync();
        public void RunWorkerAsync(object argument);
        public event DoWorkEventHandler DoWork;
        public event ProgressChangedEventHandler ProgressChanged;
        public event RunWorkerCompletedEventHandler RunWorkerCompleted;
    }

    public class ComponentCollection
    {
    }

    public interface IChangeTracking
    {
        public bool IsChanged { get; }
        public void AcceptChanges();
    }

    public interface IComponent: IDisposable
    {
        public ISite Site { get; set; }
        public event EventHandler Disposed;
    }

    [ComVisibleAttribute(..)]
    public interface IContainer: IDisposable
    {
        public ComponentCollection Components { get; }
        public void Add(IComponent component);
        public void Add(IComponent component, string name);
        public void Remove(IComponent component);
    }

    [DefaultMemberAttribute(..)]
    public interface IDataErrorInfo
    {
        public string Error { get; }
        public string this[string columnName] { get; }
    }

    public interface IEditableObject
    {
        public void BeginEdit();
        public void CancelEdit();
        public void EndEdit();
    }

    public interface INotifyDataErrorInfo
    {
        public bool HasErrors { get; }
        public IEnumerable GetErrors(string propertyName);
        public event EventHandler`1<DataErrorsChangedEventArgs> ErrorsChanged;
    }

    public interface INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
    }

    public interface IRevertibleChangeTracking: IChangeTracking
    {
        public void RejectChanges();
    }

    [ComVisibleAttribute(..)]
    public interface ISite: IServiceProvider
    {
        public IComponent Component { get; }
        public IContainer Container { get; }
        public bool DesignMode { get; }
        public string Name { get; set; }
    }

    public interface ITypeDescriptorContext: IServiceProvider
    {
        public IContainer Container { get; }
        public object Instance { get; }
        public PropertyDescriptor PropertyDescriptor { get; }
        public void OnComponentChanged();
        public bool OnComponentChanging();
    }

    public abstract class PropertyDescriptor
    {
    }

    public class TypeConverter
    {
        public TypeConverter();
        public virtual bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
        public bool CanConvertFrom(Type sourceType);
        public virtual bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
        public bool CanConvertTo(Type destinationType);
        public virtual object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
        public object ConvertFrom(object value);
        public object ConvertFromString(string text);
        public virtual object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
        public object ConvertTo(object value, Type destinationType);
        public string ConvertToString(object value);
    }

    public enum EditorBrowsableState
    {
        Advanced,
        Always,
        Never,
    }

    public enum ListSortDirection
    {
        Ascending,
        Descending,
    }

    public class AsyncCompletedEventArgs: EventArgs
    {
        public AsyncCompletedEventArgs(Exception error, bool cancelled, object userState);
        public bool Cancelled { get; }
        public Exception Error { get; }
        public object UserState { get; }
        protected void RaiseExceptionIfNecessary();
    }

    public delegate void AsyncCompletedEventHandler(object sender, AsyncCompletedEventArgs e);

    public class CancelEventArgs: EventArgs
    {
        public CancelEventArgs();
        public CancelEventArgs(bool cancel);
        public bool Cancel { get; set; }
    }

    public sealed class DataErrorsChangedEventArgs: EventArgs
    {
        public DataErrorsChangedEventArgs(string propertyName);
        public string PropertyName { get; set; }
    }

    public class DoWorkEventArgs: EventArgs
    {
        public DoWorkEventArgs(object argument);
        public object Argument { get; }
        public bool Cancel { get; set; }
        public object Result { get; set; }
    }

    public delegate void DoWorkEventHandler(object sender, DoWorkEventArgs e);

    public class ProgressChangedEventArgs: EventArgs
    {
        public ProgressChangedEventArgs(int progressPercentage, object userState);
        public int ProgressPercentage { get; }
        public object UserState { get; }
    }

    public delegate void ProgressChangedEventHandler(object sender, ProgressChangedEventArgs e);

    public class PropertyChangedEventArgs: EventArgs
    {
        public PropertyChangedEventArgs(string propertyName);
        public string PropertyName { get; }
    }

    public delegate void PropertyChangedEventHandler(object sender, PropertyChangedEventArgs e);

    public class RunWorkerCompletedEventArgs: AsyncCompletedEventArgs
    {
        public RunWorkerCompletedEventArgs(object result, Exception error, bool cancelled);
        public object Result { get; }
    }

    public delegate void RunWorkerCompletedEventHandler(object sender, RunWorkerCompletedEventArgs e);

    [AttributeUsageAttribute(..)]
    public class CategoryAttribute: Attribute, _Attribute
    {
        public CategoryAttribute();
        public CategoryAttribute(string category);
        public static CategoryAttribute Action { get; }
        public static CategoryAttribute Appearance { get; }
        public static CategoryAttribute Asynchronous { get; }
        public static CategoryAttribute Behavior { get; }
        public string Category { get; }
        public static CategoryAttribute Data { get; }
        public static CategoryAttribute Default { get; }
        public static CategoryAttribute Design { get; }
        public static CategoryAttribute DragDrop { get; }
        public static CategoryAttribute Focus { get; }
        public static CategoryAttribute Format { get; }
        public static CategoryAttribute Key { get; }
        public static CategoryAttribute Layout { get; }
        public static CategoryAttribute Mouse { get; }
        public static CategoryAttribute WindowStyle { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
        protected virtual string GetLocalizedString(string value);
    }

    [AttributeUsageAttribute(..)]
    public class DefaultValueAttribute: Attribute, _Attribute
    {
        public DefaultValueAttribute(bool value);
        public DefaultValueAttribute(byte value);
        public DefaultValueAttribute(char value);
        public DefaultValueAttribute(double value);
        public DefaultValueAttribute(float value);
        public DefaultValueAttribute(int value);
        public DefaultValueAttribute(long value);
        public DefaultValueAttribute(object value);
        public DefaultValueAttribute(short value);
        public DefaultValueAttribute(string value);
        public DefaultValueAttribute(Type type, string value);
        public virtual object Value { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
        protected void SetValue(object value);
    }

    [AttributeUsageAttribute(..)]
    public class DescriptionAttribute: Attribute, _Attribute
    {
        public DescriptionAttribute();
        public DescriptionAttribute(string description);
        public static readonly DescriptionAttribute Default;
        public virtual string Description { get; }
        protected string DescriptionValue { get; set; }
        public override bool Equals(object obj);
        public override int GetHashCode();
    }

    [AttributeUsageAttribute(..)]
    public sealed class EditorBrowsableAttribute: Attribute, _Attribute
    {
        public EditorBrowsableAttribute();
        public EditorBrowsableAttribute(EditorBrowsableState state);
        public EditorBrowsableState State { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
    }

    [AttributeUsageAttribute(..)]
    public sealed class ReadOnlyAttribute: Attribute, _Attribute
    {
        public ReadOnlyAttribute(bool isReadOnly);
        public bool IsReadOnly { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
    }

    [AttributeUsageAttribute(..)]
    [ComVisibleAttribute(..)]
    public sealed class TypeConverterAttribute: Attribute, _Attribute
    {
        public TypeConverterAttribute();
        public TypeConverterAttribute(string typeName);
        public TypeConverterAttribute(Type type);
        public string ConverterTypeName { get; }
    }

} 

namespace System.Diagnostics
{
    public abstract sealed class Debug
    {
        public static void Assert(bool condition);
        public static void Assert(bool condition, string message);
        public static void Assert(bool condition, string message, string detailMessage);
        public static void Assert(bool condition, string message, string detailMessageFormat, params object[] args);
        public static void WriteLine(object value);
        public static void WriteLine(string message);
        public static void WriteLine(string format, params object[] args);
    }

} 

namespace System.Text.RegularExpressions
{
    public class Capture
    {
        public int Index { get; }
        public int Length { get; }
        public string Value { get; }
        public override string ToString();
    }

    public class Group: Capture
    {
        public CaptureCollection Captures { get; }
        public bool Success { get; }
    }

    public class Match: Group
    {
        public static Match Empty { get; }
        public virtual GroupCollection Groups { get; }
        public Match NextMatch();
        public virtual string Result(string replacement);
    }

    public class Regex
    {
        protected Regex();
        public Regex(string pattern);
        public Regex(string pattern, RegexOptions options);
        protected Dictionary`2<string,int> capnames;
        protected Dictionary`2<int,int> caps;
        protected int capsize;
        protected string[] capslist;
        protected string pattern;
        protected RegexOptions roptions;
        public static int CacheSize { get; set; }
        public RegexOptions Options { get; }
        public bool RightToLeft { get; }
        public static string Escape(string str);
        public string[] GetGroupNames();
        public int[] GetGroupNumbers();
        public string GroupNameFromNumber(int i);
        public int GroupNumberFromName(string name);
        protected void InitializeReferences();
        public bool IsMatch(string input);
        public bool IsMatch(string input, int startat);
        public static bool IsMatch(string input, string pattern);
        public static bool IsMatch(string input, string pattern, RegexOptions options);
        public Match Match(string input);
        public Match Match(string input, int startat);
        public Match Match(string input, int beginning, int length);
        public static Match Match(string input, string pattern);
        public static Match Match(string input, string pattern, RegexOptions options);
        public MatchCollection Matches(string input);
        public MatchCollection Matches(string input, int startat);
        public static MatchCollection Matches(string input, string pattern);
        public static MatchCollection Matches(string input, string pattern, RegexOptions options);
        public string Replace(string input, MatchEvaluator evaluator);
        public string Replace(string input, MatchEvaluator evaluator, int count);
        public string Replace(string input, MatchEvaluator evaluator, int count, int startat);
        public string Replace(string input, string replacement);
        public string Replace(string input, string replacement, int count);
        public string Replace(string input, string replacement, int count, int startat);
        public static string Replace(string input, string pattern, MatchEvaluator evaluator);
        public static string Replace(string input, string pattern, MatchEvaluator evaluator, RegexOptions options);
        public static string Replace(string input, string pattern, string replacement);
        public static string Replace(string input, string pattern, string replacement, RegexOptions options);
        public string[] Split(string input);
        public string[] Split(string input, int count);
        public string[] Split(string input, int count, int startat);
        public static string[] Split(string input, string pattern);
        public static string[] Split(string input, string pattern, RegexOptions options);
        public override string ToString();
        public static string Unescape(string str);
        protected bool UseOptionR();
    }

    [FlagsAttribute(..)]
    public enum RegexOptions
    {
        CultureInvariant,
        ECMAScript,
        ExplicitCapture,
        IgnoreCase,
        IgnorePatternWhitespace,
        Multiline,
        None,
        RightToLeft,
        Singleline,
    }

    [DefaultMemberAttribute(..)]
    public class CaptureCollection: ICollection
    {
        public int Count { get; }
        public bool IsReadOnly { get; }
        public bool IsSynchronized { get; }
        public object SyncRoot { get; }
        public Capture this[int i] { get; }
        public void CopyTo(Array array, int arrayIndex);
        public IEnumerator GetEnumerator();
    }

    [DefaultMemberAttribute(..)]
    public class GroupCollection: ICollection
    {
        public int Count { get; }
        public bool IsReadOnly { get; }
        public bool IsSynchronized { get; }
        public object SyncRoot { get; }
        public Group this[int groupnum] { get; }
        public Group this[string groupname] { get; }
        public void CopyTo(Array array, int arrayIndex);
        public IEnumerator GetEnumerator();
    }

    [DefaultMemberAttribute(..)]
    public class MatchCollection: ICollection
    {
        public int Count { get; }
        public bool IsReadOnly { get; }
        public bool IsSynchronized { get; }
        public object SyncRoot { get; }
        public virtual Match this[int i] { get; }
        public void CopyTo(Array array, int arrayIndex);
        public IEnumerator GetEnumerator();
    }

    public delegate string MatchEvaluator(Match match);

} 

namespace System.Net
{
    public sealed class Cookie
    {
        public Cookie();
        public Cookie(string name, string value);
        public Cookie(string name, string value, string path);
        public Cookie(string name, string value, string path, string domain);
        public string Comment { get; set; }
        public Uri CommentUri { get; set; }
        public bool Discard { get; set; }
        public string Domain { get; set; }
        public bool Expired { get; set; }
        public DateTime Expires { get; set; }
        public bool HttpOnly { get; set; }
        public string Name { get; set; }
        public string Path { get; set; }
        public string Port { get; set; }
        public bool Secure { get; set; }
        public DateTime TimeStamp { get; }
        public string Value { get; set; }
        public int Version { get; set; }
        public override bool Equals(object comparand);
        public override int GetHashCode();
        public override string ToString();
    }

    public sealed class CookieContainer
    {
        public CookieContainer();
        public const int DefaultCookieLengthLimit;
        public const int DefaultCookieLimit;
        public const int DefaultPerDomainCookieLimit;
        public int Capacity { get; }
        public int Count { get; }
        public int MaxCookieSize { get; }
        public int PerDomainCapacity { get; }
        public void Add(Uri uri, Cookie cookie);
        public void Add(Uri uri, CookieCollection cookies);
        public string GetCookieHeader(Uri uri);
        public CookieCollection GetCookies(Uri uri);
        public void SetCookies(Uri uri, string cookieHeader);
    }

    public sealed class DnsEndPoint: EndPoint
    {
        public DnsEndPoint(string host, int port);
        public DnsEndPoint(string host, int port, AddressFamily addressFamily);
        public string Host { get; }
        public int Port { get; }
        public override bool Equals(object comparand);
        public override int GetHashCode();
        public override string ToString();
    }

    public abstract class EndPoint
    {
        protected EndPoint();
        public virtual AddressFamily AddressFamily { get; }
        public virtual EndPoint Create(SocketAddress socketAddress);
        public virtual SocketAddress Serialize();
    }

    public abstract class HttpWebRequest: WebRequest
    {
        protected HttpWebRequest();
        public string Accept { get; set; }
        public virtual bool AllowReadStreamBuffering { get; set; }
        public virtual CookieContainer CookieContainer { get; set; }
        public virtual bool HaveResponse { get; }
        public override void Abort();
        public override IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state);
        public override IAsyncResult BeginGetResponse(AsyncCallback callback, object state);
        public override Stream EndGetRequestStream(IAsyncResult asyncResult);
        public override WebResponse EndGetResponse(IAsyncResult asyncResult);
    }

    public abstract class HttpWebResponse: WebResponse, IDisposable
    {
        protected HttpWebResponse();
        public virtual CookieCollection Cookies { get; }
        public abstract string Method { get; }
        public abstract HttpStatusCode StatusCode { get; }
        public abstract string StatusDescription { get; }
    }

    public interface ICredentials
    {
        public NetworkCredential GetCredential(Uri uri, string authType);
    }

    public class IPAddress
    {
        public IPAddress(byte[] address);
        public IPAddress(byte[] address, long scopeid);
        public IPAddress(long newAddress);
        public static readonly IPAddress Any;
        public static readonly IPAddress Broadcast;
        public static readonly IPAddress IPv6Any;
        public static readonly IPAddress IPv6Loopback;
        public static readonly IPAddress IPv6None;
        public static readonly IPAddress Loopback;
        public static readonly IPAddress None;
        public long Address { get; set; }
        public AddressFamily AddressFamily { get; }
        public bool IsIPv6LinkLocal { get; }
        public bool IsIPv6Multicast { get; }
        public bool IsIPv6SiteLocal { get; }
        public long ScopeId { get; set; }
        public override bool Equals(object comparand);
        public byte[] GetAddressBytes();
        public override int GetHashCode();
        public static int HostToNetworkOrder(int host);
        public static long HostToNetworkOrder(long host);
        public static short HostToNetworkOrder(short host);
        public static bool IsLoopback(IPAddress address);
        public static int NetworkToHostOrder(int network);
        public static long NetworkToHostOrder(long network);
        public static short NetworkToHostOrder(short network);
        public static IPAddress Parse(string ipString);
        public override string ToString();
        public static bool TryParse(string ipString, ref IPAddress address);
    }

    public class IPEndPoint: EndPoint
    {
        public IPEndPoint(IPAddress address, int port);
        public IPEndPoint(long address, int port);
        public const int MaxPort;
        public const int MinPort;
        public IPAddress Address { get; set; }
        public int Port { get; set; }
        public override EndPoint Create(SocketAddress socketAddress);
        public override bool Equals(object comparand);
        public override int GetHashCode();
        public override SocketAddress Serialize();
        public override string ToString();
    }

    public interface IWebRequestCreate
    {
        public WebRequest Create(Uri uri);
    }

    public class NetworkCredential: ICredentials
    {
        public NetworkCredential();
        public NetworkCredential(string userName, string password);
        public NetworkCredential(string userName, string password, string domain);
        public string Domain { get; set; }
        public string Password { get; set; }
        public string UserName { get; set; }
        public NetworkCredential GetCredential(Uri uri, string authType);
    }

    [DefaultMemberAttribute(..)]
    public class SocketAddress
    {
        public SocketAddress(AddressFamily family);
        public SocketAddress(AddressFamily family, int size);
        public AddressFamily Family { get; }
        public int Size { get; }
        public byte this[int offset] { get; set; }
        public override bool Equals(object comparand);
        public override int GetHashCode();
        public override string ToString();
    }

    public class WebClient
    {
        public WebClient();
        public bool AllowReadStreamBuffering { get; set; }
        public string BaseAddress { get; set; }
        public ICredentials Credentials { get; set; }
        public Encoding Encoding { get; set; }
        public WebHeaderCollection Headers { get; set; }
        public bool IsBusy { get; }
        public WebHeaderCollection ResponseHeaders { get; }
        public bool UseDefaultCredentials { get; set; }
        public void CancelAsync();
        public void DownloadStringAsync(Uri address);
        public void DownloadStringAsync(Uri address, object userToken);
        protected virtual WebRequest GetWebRequest(Uri address);
        protected virtual WebResponse GetWebResponse(WebRequest request, IAsyncResult result);
        protected virtual void OnDownloadProgressChanged(DownloadProgressChangedEventArgs e);
        protected virtual void OnDownloadStringCompleted(DownloadStringCompletedEventArgs e);
        protected virtual void OnOpenReadCompleted(OpenReadCompletedEventArgs e);
        protected virtual void OnOpenWriteCompleted(OpenWriteCompletedEventArgs e);
        protected virtual void OnUploadProgressChanged(UploadProgressChangedEventArgs e);
        protected virtual void OnUploadStringCompleted(UploadStringCompletedEventArgs e);
        protected virtual void OnWriteStreamClosed(WriteStreamClosedEventArgs e);
        public void OpenReadAsync(Uri address);
        public void OpenReadAsync(Uri address, object userToken);
        public void OpenWriteAsync(Uri address);
        public void OpenWriteAsync(Uri address, string method);
        public void OpenWriteAsync(Uri address, string method, object userToken);
        public void UploadStringAsync(Uri address, string data);
        public void UploadStringAsync(Uri address, string method, string data);
        public void UploadStringAsync(Uri address, string method, string data, object userToken);
        public event DownloadProgressChangedEventHandler DownloadProgressChanged;
        public event DownloadStringCompletedEventHandler DownloadStringCompleted;
        public event OpenReadCompletedEventHandler OpenReadCompleted;
        public event OpenWriteCompletedEventHandler OpenWriteCompleted;
        public event UploadProgressChangedEventHandler UploadProgressChanged;
        public event UploadStringCompletedEventHandler UploadStringCompleted;
        public event WriteStreamClosedEventHandler WriteStreamClosed;
    }

    public abstract class WebRequest
    {
        protected WebRequest();
        public abstract string ContentType { get; set; }
        public virtual IWebRequestCreate CreatorInstance { get; }
        public virtual ICredentials Credentials { get; set; }
        public abstract WebHeaderCollection Headers { get; set; }
        public abstract string Method { get; set; }
        public abstract Uri RequestUri { get; }
        public virtual bool UseDefaultCredentials { get; set; }
        public abstract void Abort();
        public abstract IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state);
        public abstract IAsyncResult BeginGetResponse(AsyncCallback callback, object state);
        public static WebRequest Create(string requestUriString);
        public static WebRequest Create(Uri requestUri);
        public abstract Stream EndGetRequestStream(IAsyncResult asyncResult);
        public abstract WebResponse EndGetResponse(IAsyncResult asyncResult);
        public static bool RegisterPrefix(string prefix, IWebRequestCreate creator);
    }

    public abstract class WebResponse: IDisposable
    {
        protected WebResponse();
        public abstract long ContentLength { get; }
        public abstract string ContentType { get; }
        public virtual WebHeaderCollection Headers { get; }
        public abstract Uri ResponseUri { get; }
        public abstract void Close();
        public abstract Stream GetResponseStream();
    }

    public enum HttpRequestHeader
    {
        Accept,
        AcceptCharset,
        AcceptEncoding,
        AcceptLanguage,
        Allow,
        Authorization,
        CacheControl,
        Connection,
        ContentEncoding,
        ContentLanguage,
        ContentLength,
        ContentLocation,
        ContentMd5,
        ContentRange,
        ContentType,
        Cookie,
        Date,
        Expect,
        Expires,
        From,
        Host,
        IfMatch,
        IfModifiedSince,
        IfNoneMatch,
        IfRange,
        IfUnmodifiedSince,
        KeepAlive,
        LastModified,
        MaxForwards,
        Pragma,
        ProxyAuthorization,
        Range,
        Referer,
        Te,
        Trailer,
        TransferEncoding,
        Translate,
        Upgrade,
        UserAgent,
        Via,
        Warning,
    }

    public enum HttpStatusCode
    {
        Accepted,
        Ambiguous,
        BadGateway,
        BadRequest,
        Conflict,
        Continue,
        Created,
        ExpectationFailed,
        Forbidden,
        Found,
        GatewayTimeout,
        Gone,
        HttpVersionNotSupported,
        InternalServerError,
        LengthRequired,
        MethodNotAllowed,
        Moved,
        MovedPermanently,
        MultipleChoices,
        NoContent,
        NonAuthoritativeInformation,
        NotAcceptable,
        NotFound,
        NotImplemented,
        NotModified,
        OK,
        PartialContent,
        PaymentRequired,
        PreconditionFailed,
        ProxyAuthenticationRequired,
        Redirect,
        RedirectKeepVerb,
        RedirectMethod,
        RequestedRangeNotSatisfiable,
        RequestEntityTooLarge,
        RequestTimeout,
        RequestUriTooLong,
        ResetContent,
        SeeOther,
        ServiceUnavailable,
        SwitchingProtocols,
        TemporaryRedirect,
        Unauthorized,
        UnsupportedMediaType,
        Unused,
        UseProxy,
    }

    public enum WebExceptionStatus
    {
        ConnectFailure,
        MessageLengthLimitExceeded,
        Pending,
        RequestCanceled,
        SendFailure,
        Success,
        UnknownError,
    }

    [DefaultMemberAttribute(..)]
    public sealed class CookieCollection: ICollection
    {
        public CookieCollection();
        public int Count { get; }
        public bool IsReadOnly { get; }
        public bool IsSynchronized { get; }
        public object SyncRoot { get; }
        public Cookie this[string name] { get; }
        public void Add(Cookie cookie);
        public void Add(CookieCollection cookies);
        public void CopyTo(Array array, int index);
        public IEnumerator GetEnumerator();
    }

    [DefaultMemberAttribute(..)]
    public sealed class WebHeaderCollection: IEnumerable
    {
        public WebHeaderCollection();
        public string[] AllKeys { get; }
        public int Count { get; }
        public string this[HttpRequestHeader header] { get; set; }
        public string this[string name] { get; set; }
    }

    public class DownloadProgressChangedEventArgs: ProgressChangedEventArgs
    {
        public long BytesReceived { get; }
        public long TotalBytesToReceive { get; }
    }

    public delegate void DownloadProgressChangedEventHandler(object sender, DownloadProgressChangedEventArgs e);

    public class DownloadStringCompletedEventArgs: AsyncCompletedEventArgs
    {
        public string Result { get; }
    }

    public delegate void DownloadStringCompletedEventHandler(object sender, DownloadStringCompletedEventArgs e);

    public class OpenReadCompletedEventArgs: AsyncCompletedEventArgs
    {
        public Stream Result { get; }
    }

    public delegate void OpenReadCompletedEventHandler(object sender, OpenReadCompletedEventArgs e);

    public class OpenWriteCompletedEventArgs: AsyncCompletedEventArgs
    {
        public Stream Result { get; }
    }

    public delegate void OpenWriteCompletedEventHandler(object sender, OpenWriteCompletedEventArgs e);

    public class UploadProgressChangedEventArgs: ProgressChangedEventArgs
    {
        public long BytesReceived { get; }
        public long BytesSent { get; }
        public long TotalBytesToReceive { get; }
        public long TotalBytesToSend { get; }
    }

    public delegate void UploadProgressChangedEventHandler(object sender, UploadProgressChangedEventArgs e);

    public class UploadStringCompletedEventArgs: AsyncCompletedEventArgs
    {
        public string Result { get; }
    }

    public delegate void UploadStringCompletedEventHandler(object sender, UploadStringCompletedEventArgs e);

    public class WriteStreamClosedEventArgs: EventArgs
    {
        public Exception Error { get; }
    }

    public delegate void WriteStreamClosedEventHandler(object sender, WriteStreamClosedEventArgs e);

    public class CookieException: FormatException, _Exception, ISerializable
    {
        public CookieException();
    }

    public class ProtocolViolationException: InvalidOperationException, _Exception, ISerializable
    {
        public ProtocolViolationException();
        public ProtocolViolationException(string message);
    }

    public class WebException: InvalidOperationException, _Exception, ISerializable
    {
        public WebException();
        public WebException(string message);
        public WebException(string message, Exception innerException);
        public WebException(string message, Exception innerException, WebExceptionStatus status, WebResponse response);
        public WebException(string message, WebExceptionStatus status);
        public WebResponse Response { get; }
        public WebExceptionStatus Status { get; }
    }

} 

namespace System.Net.NetworkInformation
{
    public abstract class NetworkChange
    {
        protected NetworkChange();
        public static event NetworkAddressChangedEventHandler NetworkAddressChanged;
    }

    public abstract class NetworkInterface
    {
        protected NetworkInterface();
        public static bool GetIsNetworkAvailable();
    }

    public delegate void NetworkAddressChangedEventHandler(object sender, EventArgs e);

} 

namespace System.Net.Sockets
{
    [SecuritySafeCriticalAttribute(..)]
    public class Socket: IDisposable
    {
        public Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType);
        public AddressFamily AddressFamily { get; }
        public bool Connected { get; }
        public bool NoDelay { get; set; }
        public static bool OSSupportsIPv4 { get; }
        public static bool OSSupportsIPv6 { get; }
        public ProtocolType ProtocolType { get; }
        public int ReceiveBufferSize { get; set; }
        public EndPoint RemoteEndPoint { get; }
        public int SendBufferSize { get; set; }
        public short Ttl { get; set; }
        public static void CancelConnectAsync(SocketAsyncEventArgs e);
        public void Close();
        public void Close(int timeout);
        public bool ConnectAsync(SocketAsyncEventArgs e);
        public static bool ConnectAsync(SocketType socketType, ProtocolType protocolType, SocketAsyncEventArgs e);
        public void Dispose();
        protected virtual void Dispose(bool disposing);
        protected override void Finalize();
        public bool ReceiveAsync(SocketAsyncEventArgs e);
        public bool SendAsync(SocketAsyncEventArgs e);
        public void Shutdown(SocketShutdown how);
    }

    public class UdpAnySourceMulticastClient: IDisposable
    {
        public UdpAnySourceMulticastClient(IPAddress groupAddress, int localPort);
        public bool MulticastLoopback { get; set; }
        public int ReceiveBufferSize { get; set; }
        public int SendBufferSize { get; set; }
        public IAsyncResult BeginJoinGroup(AsyncCallback callback, object state);
        public IAsyncResult BeginReceiveFromGroup(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
        public IAsyncResult BeginSendTo(byte[] buffer, int offset, int count, IPEndPoint remoteEndPoint, AsyncCallback callback, object state);
        public IAsyncResult BeginSendToGroup(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
        public void BlockSource(IPAddress sourceAddress);
        public void Dispose();
        public void EndJoinGroup(IAsyncResult result);
        public int EndReceiveFromGroup(IAsyncResult result, ref IPEndPoint source);
        public void EndSendTo(IAsyncResult result);
        public void EndSendToGroup(IAsyncResult result);
        public void UnblockSource(IPAddress sourceAddress);
    }

    public class UdpSingleSourceMulticastClient: IDisposable
    {
        public UdpSingleSourceMulticastClient(IPAddress sourceAddress, IPAddress groupAddress, int localPort);
        public int ReceiveBufferSize { get; set; }
        public int SendBufferSize { get; set; }
        public IAsyncResult BeginJoinGroup(AsyncCallback callback, object state);
        public IAsyncResult BeginReceiveFromSource(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
        public IAsyncResult BeginSendToSource(byte[] buffer, int offset, int count, int remotePort, AsyncCallback callback, object state);
        public void Dispose();
        public void EndJoinGroup(IAsyncResult result);
        public int EndReceiveFromSource(IAsyncResult result, ref int sourcePort);
        public void EndSendToSource(IAsyncResult result);
    }

    public enum AddressFamily
    {
        InterNetwork,
        InterNetworkV6,
        Unknown,
        Unspecified,
    }

    public enum ProtocolType
    {
        Tcp,
        Unknown,
        Unspecified,
    }

    public enum SocketAsyncOperation
    {
        Connect,
        None,
        Receive,
        Send,
    }

    public enum SocketError
    {
        AccessDenied,
        AddressAlreadyInUse,
        AddressFamilyNotSupported,
        AddressNotAvailable,
        AlreadyInProgress,
        ConnectionAborted,
        ConnectionRefused,
        ConnectionReset,
        DestinationAddressRequired,
        Disconnecting,
        Fault,
        HostDown,
        HostNotFound,
        HostUnreachable,
        InProgress,
        Interrupted,
        InvalidArgument,
        IOPending,
        IsConnected,
        MessageSize,
        NetworkDown,
        NetworkReset,
        NetworkUnreachable,
        NoBufferSpaceAvailable,
        NoData,
        NoRecovery,
        NotConnected,
        NotInitialized,
        NotSocket,
        OperationAborted,
        OperationNotSupported,
        ProcessLimit,
        ProtocolFamilyNotSupported,
        ProtocolNotSupported,
        ProtocolOption,
        ProtocolType,
        Shutdown,
        SocketError,
        SocketNotSupported,
        Success,
        SystemNotReady,
        TimedOut,
        TooManyOpenSockets,
        TryAgain,
        TypeNotFound,
        VersionNotSupported,
        WouldBlock,
    }

    public enum SocketShutdown
    {
        Both,
        Receive,
        Send,
    }

    public enum SocketType
    {
        Stream,
        Unknown,
    }

    public class SocketAsyncEventArgs: EventArgs, IDisposable
    {
        public SocketAsyncEventArgs();
        public byte[] Buffer { get; }
        public IList`1<ArraySegment`1<byte>> BufferList { get; set; }
        public int BytesTransferred { get; }
        public Exception ConnectByNameError { get; }
        public Socket ConnectSocket { get; }
        public int Count { get; }
        public SocketAsyncOperation LastOperation { get; }
        public int Offset { get; }
        public EndPoint RemoteEndPoint { get; set; }
        public SocketError SocketError { get; set; }
        public object UserToken { get; set; }
        public void Dispose();
        protected override void Finalize();
        protected virtual void OnCompleted(SocketAsyncEventArgs e);
        public void SetBuffer(byte[] buffer, int offset, int count);
        public void SetBuffer(int offset, int count);
        public event EventHandler`1<SocketAsyncEventArgs> Completed;
    }

    public class SocketException: Exception, _Exception, ISerializable
    {
        public SocketException();
        public SocketException(int errorCode);
        public int ErrorCode { get; }
        public SocketError SocketErrorCode { get; }
    }

} 

namespace System.Runtime.Serialization
{
    public sealed class DataContractSerializer: XmlObjectSerializer
    {
        public DataContractSerializer(Type type);
        public DataContractSerializer(Type type, IEnumerable`1<Type> knownTypes);
        public DataContractSerializer(Type type, string rootName, string rootNamespace);
        public DataContractSerializer(Type type, string rootName, string rootNamespace, IEnumerable`1<Type> knownTypes);
        public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace);
        public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace, IEnumerable`1<Type> knownTypes);
        public bool IgnoreExtensionDataObject { get; }
        public ReadOnlyCollection`1<Type> KnownTypes { get; }
        public int MaxItemsInObjectGraph { get; }
        public bool PreserveObjectReferences { get; }
        public override bool IsStartObject(XmlDictionaryReader reader);
        public override bool IsStartObject(XmlReader reader);
        public override object ReadObject(XmlDictionaryReader reader, bool verifyObjectName);
        public override object ReadObject(XmlReader reader);
        public override object ReadObject(XmlReader reader, bool verifyObjectName);
        public override void WriteEndObject(XmlDictionaryWriter writer);
        public override void WriteEndObject(XmlWriter writer);
        public override void WriteObject(XmlWriter writer, object graph);
        public override void WriteObjectContent(XmlDictionaryWriter writer, object graph);
        public override void WriteObjectContent(XmlWriter writer, object graph);
        public override void WriteStartObject(XmlDictionaryWriter writer, object graph);
        public override void WriteStartObject(XmlWriter writer, object graph);
    }

    public abstract class XmlObjectSerializer
    {
        protected XmlObjectSerializer();
        public abstract bool IsStartObject(XmlDictionaryReader reader);
        public virtual bool IsStartObject(XmlReader reader);
        public virtual object ReadObject(Stream stream);
        public virtual object ReadObject(XmlDictionaryReader reader);
        public abstract object ReadObject(XmlDictionaryReader reader, bool verifyObjectName);
        public virtual object ReadObject(XmlReader reader);
        public virtual object ReadObject(XmlReader reader, bool verifyObjectName);
        public abstract void WriteEndObject(XmlDictionaryWriter writer);
        public virtual void WriteEndObject(XmlWriter writer);
        public virtual void WriteObject(Stream stream, object graph);
        public virtual void WriteObject(XmlDictionaryWriter writer, object graph);
        public virtual void WriteObject(XmlWriter writer, object graph);
        public abstract void WriteObjectContent(XmlDictionaryWriter writer, object graph);
        public virtual void WriteObjectContent(XmlWriter writer, object graph);
        public abstract void WriteStartObject(XmlDictionaryWriter writer, object graph);
        public virtual void WriteStartObject(XmlWriter writer, object graph);
    }

    [AttributeUsageAttribute(..)]
    public sealed class CollectionDataContractAttribute: Attribute, _Attribute
    {
        public CollectionDataContractAttribute();
        public bool IsReference { get; set; }
        public string ItemName { get; set; }
        public string KeyName { get; set; }
        public string Name { get; set; }
        public string Namespace { get; set; }
        public string ValueName { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class ContractNamespaceAttribute: Attribute, _Attribute
    {
        public ContractNamespaceAttribute(string contractNamespace);
        public string ClrNamespace { get; set; }
        public string ContractNamespace { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class DataContractAttribute: Attribute, _Attribute
    {
        public DataContractAttribute();
        public bool IsReference { get; set; }
        public string Name { get; set; }
        public string Namespace { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class DataMemberAttribute: Attribute, _Attribute
    {
        public DataMemberAttribute();
        public bool EmitDefaultValue { get; set; }
        public bool IsRequired { get; set; }
        public string Name { get; set; }
        public int Order { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class EnumMemberAttribute: Attribute, _Attribute
    {
        public EnumMemberAttribute();
        public string Value { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class IgnoreDataMemberAttribute: Attribute, _Attribute
    {
        public IgnoreDataMemberAttribute();
    }

    [AttributeUsageAttribute(..)]
    public sealed class KnownTypeAttribute: Attribute, _Attribute
    {
        public KnownTypeAttribute(string methodName);
        public KnownTypeAttribute(Type type);
        public string MethodName { get; }
        public Type Type { get; }
    }

    public class InvalidDataContractException: Exception, _Exception, ISerializable
    {
        public InvalidDataContractException();
        public InvalidDataContractException(string message);
        public InvalidDataContractException(string message, Exception innerException);
    }

} 

namespace System.Xml
{
    public interface IXmlDictionary
    {
        public bool TryLookup(int key, ref XmlDictionaryString result);
        public bool TryLookup(string value, ref XmlDictionaryString result);
        public bool TryLookup(XmlDictionaryString value, ref XmlDictionaryString result);
    }

    public class UniqueId
    {
        public UniqueId();
        public UniqueId(byte[] guid);
        public UniqueId(byte[] guid, int offset);
        public UniqueId(char[] chars, int offset, int count);
        public UniqueId(Guid guid);
        public UniqueId(string value);
        public int CharArrayLength { get; }
        public bool IsGuid { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
        public int ToCharArray(char[] chars, int offset);
        public override string ToString();
        public bool TryGetGuid(byte[] buffer, int offset);
        public bool TryGetGuid(ref Guid guid);
        public static bool operator ==(UniqueId id1, UniqueId id2);
        public static bool operator !=(UniqueId id1, UniqueId id2);
    }

    public class XmlBinaryReaderSession: IXmlDictionary
    {
        public XmlBinaryReaderSession();
        public XmlDictionaryString Add(int id, string value);
        public void Clear();
        public bool TryLookup(int key, ref XmlDictionaryString result);
        public bool TryLookup(string value, ref XmlDictionaryString result);
        public bool TryLookup(XmlDictionaryString value, ref XmlDictionaryString result);
    }

    public class XmlBinaryWriterSession
    {
        public XmlBinaryWriterSession();
        public void Reset();
        public virtual bool TryAdd(XmlDictionaryString value, ref int key);
    }

    public class XmlDictionary: IXmlDictionary
    {
        public XmlDictionary();
        public XmlDictionary(int capacity);
        public static IXmlDictionary Empty { get; }
        public virtual XmlDictionaryString Add(string value);
        public virtual bool TryLookup(int key, ref XmlDictionaryString result);
        public virtual bool TryLookup(string value, ref XmlDictionaryString result);
        public virtual bool TryLookup(XmlDictionaryString value, ref XmlDictionaryString result);
    }

    [DefaultMemberAttribute(..)]
    public abstract class XmlDictionaryReader: XmlReader, IDisposable
    {
        protected XmlDictionaryReader();
        public virtual bool CanCanonicalize { get; }
        public virtual XmlDictionaryReaderQuotas Quotas { get; }
        public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, int offset, int count, IXmlDictionary dictionary, XmlDictionaryReaderQuotas quotas);
        public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, int offset, int count, IXmlDictionary dictionary, XmlDictionaryReaderQuotas quotas, XmlBinaryReaderSession session);
        public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, int offset, int count, XmlDictionaryReaderQuotas quotas);
        public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, XmlDictionaryReaderQuotas quotas);
        public static XmlDictionaryReader CreateBinaryReader(Stream stream, IXmlDictionary dictionary, XmlDictionaryReaderQuotas quotas);
        public static XmlDictionaryReader CreateBinaryReader(Stream stream, IXmlDictionary dictionary, XmlDictionaryReaderQuotas quotas, XmlBinaryReaderSession session);
        public static XmlDictionaryReader CreateBinaryReader(Stream stream, XmlDictionaryReaderQuotas quotas);
        public static XmlDictionaryReader CreateDictionaryReader(XmlReader reader);
        public virtual void EndCanonicalization();
        public virtual string GetAttribute(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual int IndexOfLocalName(string[] localNames, string namespaceUri);
        public virtual int IndexOfLocalName(XmlDictionaryString[] localNames, XmlDictionaryString namespaceUri);
        public virtual bool IsLocalName(string localName);
        public virtual bool IsLocalName(XmlDictionaryString localName);
        public virtual bool IsNamespaceUri(string namespaceUri);
        public virtual bool IsNamespaceUri(XmlDictionaryString namespaceUri);
        public virtual bool IsStartArray(ref Type type);
        public virtual bool IsStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        protected bool IsTextNode(XmlNodeType nodeType);
        public virtual void MoveToStartElement();
        public virtual void MoveToStartElement(string name);
        public virtual void MoveToStartElement(string localName, string namespaceUri);
        public virtual void MoveToStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual int ReadArray(string localName, string namespaceUri, bool[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, DateTime[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, decimal[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, double[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, float[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, Guid[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, int[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, long[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, short[] array, int offset, int count);
        public virtual int ReadArray(string localName, string namespaceUri, TimeSpan[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, bool[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, DateTime[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, decimal[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, double[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, float[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Guid[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, int[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, long[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, short[] array, int offset, int count);
        public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, TimeSpan[] array, int offset, int count);
        public virtual bool[] ReadBooleanArray(string localName, string namespaceUri);
        public virtual bool[] ReadBooleanArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public override object ReadContentAs(Type type, IXmlNamespaceResolver namespaceResolver);
        public virtual byte[] ReadContentAsBase64();
        public virtual byte[] ReadContentAsBinHex();
        protected byte[] ReadContentAsBinHex(int maxByteArrayContentLength);
        public virtual int ReadContentAsChars(char[] chars, int offset, int count);
        public override decimal ReadContentAsDecimal();
        public override float ReadContentAsFloat();
        public virtual Guid ReadContentAsGuid();
        public virtual void ReadContentAsQualifiedName(ref string localName, ref string namespaceUri);
        public override string ReadContentAsString();
        protected string ReadContentAsString(int maxStringContentLength);
        public virtual string ReadContentAsString(string[] strings, ref int index);
        public virtual string ReadContentAsString(XmlDictionaryString[] strings, ref int index);
        public virtual TimeSpan ReadContentAsTimeSpan();
        public virtual UniqueId ReadContentAsUniqueId();
        public virtual DateTime[] ReadDateTimeArray(string localName, string namespaceUri);
        public virtual DateTime[] ReadDateTimeArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual decimal[] ReadDecimalArray(string localName, string namespaceUri);
        public virtual decimal[] ReadDecimalArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual double[] ReadDoubleArray(string localName, string namespaceUri);
        public virtual double[] ReadDoubleArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual byte[] ReadElementContentAsBase64();
        public virtual byte[] ReadElementContentAsBinHex();
        public override bool ReadElementContentAsBoolean();
        public override DateTime ReadElementContentAsDateTime();
        public override decimal ReadElementContentAsDecimal();
        public override double ReadElementContentAsDouble();
        public override float ReadElementContentAsFloat();
        public virtual Guid ReadElementContentAsGuid();
        public override int ReadElementContentAsInt();
        public override long ReadElementContentAsLong();
        public override string ReadElementContentAsString();
        public virtual TimeSpan ReadElementContentAsTimeSpan();
        public virtual UniqueId ReadElementContentAsUniqueId();
        public virtual void ReadFullStartElement();
        public virtual void ReadFullStartElement(string name);
        public virtual void ReadFullStartElement(string localName, string namespaceUri);
        public virtual void ReadFullStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual Guid[] ReadGuidArray(string localName, string namespaceUri);
        public virtual Guid[] ReadGuidArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual short[] ReadInt16Array(string localName, string namespaceUri);
        public virtual short[] ReadInt16Array(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual int[] ReadInt32Array(string localName, string namespaceUri);
        public virtual int[] ReadInt32Array(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual long[] ReadInt64Array(string localName, string namespaceUri);
        public virtual long[] ReadInt64Array(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual float[] ReadSingleArray(string localName, string namespaceUri);
        public virtual float[] ReadSingleArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual void ReadStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual TimeSpan[] ReadTimeSpanArray(string localName, string namespaceUri);
        public virtual TimeSpan[] ReadTimeSpanArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual int ReadValueAsBase64(byte[] buffer, int offset, int count);
        public virtual void StartCanonicalization(Stream stream, bool includeComments, string[] inclusivePrefixes);
        public virtual bool TryGetArrayLength(ref int count);
        public virtual bool TryGetBase64ContentLength(ref int length);
        public virtual bool TryGetLocalNameAsDictionaryString(ref XmlDictionaryString localName);
        public virtual bool TryGetNamespaceUriAsDictionaryString(ref XmlDictionaryString namespaceUri);
        public virtual bool TryGetValueAsDictionaryString(ref XmlDictionaryString value);
    }

    public sealed class XmlDictionaryReaderQuotas
    {
        public static XmlDictionaryReaderQuotas Max { get; }
        public int MaxArrayLength { get; }
        public int MaxBytesPerRead { get; }
        public int MaxDepth { get; }
        public int MaxNameTableCharCount { get; }
        public int MaxStringContentLength { get; }
    }

    public class XmlDictionaryString
    {
        public XmlDictionaryString(IXmlDictionary dictionary, string value, int key);
        public IXmlDictionary Dictionary { get; }
        public static XmlDictionaryString Empty { get; }
        public int Key { get; }
        public string Value { get; }
        public override string ToString();
    }

    public abstract class XmlDictionaryWriter: XmlWriter, IDisposable
    {
        protected XmlDictionaryWriter();
        public virtual bool CanCanonicalize { get; }
        public static XmlDictionaryWriter CreateBinaryWriter(Stream stream);
        public static XmlDictionaryWriter CreateBinaryWriter(Stream stream, IXmlDictionary dictionary);
        public static XmlDictionaryWriter CreateBinaryWriter(Stream stream, IXmlDictionary dictionary, XmlBinaryWriterSession session);
        public static XmlDictionaryWriter CreateBinaryWriter(Stream stream, IXmlDictionary dictionary, XmlBinaryWriterSession session, bool ownsStream);
        public static XmlDictionaryWriter CreateDictionaryWriter(XmlWriter writer);
        public virtual void EndCanonicalization();
        public virtual void StartCanonicalization(Stream stream, bool includeComments, string[] inclusivePrefixes);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, bool[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, DateTime[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, decimal[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, double[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, float[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, Guid[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, int[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, long[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, short[] array, int offset, int count);
        public virtual void WriteArray(string prefix, string localName, string namespaceUri, TimeSpan[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, bool[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, DateTime[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, decimal[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, double[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, float[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, Guid[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, int[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, long[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, short[] array, int offset, int count);
        public virtual void WriteArray(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, TimeSpan[] array, int offset, int count);
        public void WriteAttributeString(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, string value);
        public void WriteAttributeString(XmlDictionaryString localName, XmlDictionaryString namespaceUri, string value);
        public void WriteElementString(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, string value);
        public void WriteElementString(XmlDictionaryString localName, XmlDictionaryString namespaceUri, string value);
        public virtual void WriteNode(XmlDictionaryReader reader, bool defattr);
        public override void WriteNode(XmlReader reader, bool defattr);
        public virtual void WriteQualifiedName(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual void WriteStartAttribute(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public void WriteStartAttribute(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual void WriteStartElement(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public void WriteStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri);
        public virtual void WriteString(XmlDictionaryString value);
        protected virtual void WriteTextNode(XmlDictionaryReader reader, bool isAttribute);
        public virtual void WriteValue(Guid value);
        public virtual void WriteValue(TimeSpan value);
        public virtual void WriteValue(UniqueId value);
        public virtual void WriteValue(XmlDictionaryString value);
        public virtual void WriteXmlAttribute(string localName, string value);
        public virtual void WriteXmlAttribute(XmlDictionaryString localName, XmlDictionaryString value);
        public virtual void WriteXmlnsAttribute(string prefix, string namespaceUri);
        public virtual void WriteXmlnsAttribute(string prefix, XmlDictionaryString namespaceUri);
    }

} 

namespace System.Collections.Generic
{
    [DebuggerDisplayAttribute(..)]
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class KeyedByTypeCollection`1<TItem>: KeyedCollection`2, IList, IList`1<TItem>
    {
        public KeyedByTypeCollection`1();
        public T Find<T>();
        public Collection`1<T> FindAll<T>();
        protected override Type GetKeyForItem(TItem item);
        protected override void InsertItem(int index, TItem item);
        public T Remove<T>();
        public Collection`1<T> RemoveAll<T>();
        protected override void SetItem(int index, TItem item);
    }

    [ComVisibleAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class SynchronizedReadOnlyCollection`1<T>: IList, IList`1<T>
    {
        public SynchronizedReadOnlyCollection`1(object syncRoot, IEnumerable`1<T> list);
        public int Count { get; }
        protected IList`1<T> Items { get; }
        public T this[int index] { get; }
        public bool Contains(T value);
        public void CopyTo(T[] array, int index);
        public IEnumerator`1<T> GetEnumerator();
        public int IndexOf(T value);
    }

} 

namespace System.Configuration
{
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public abstract class ConfigurationElement: Dictionary`2, IDeserializationCallback, IDictionary, IDictionary`2, ISerializable
    {
        protected ConfigurationElement();
        public object this[string key] { get; set; }
        protected static void ReadEmptyElement(XmlReader reader);
        public abstract void ReadXml(XmlReader reader);
    }

} 

namespace System.ServiceModel
{
    public class BasicHttpBinding: Binding, IDefaultCommunicationTimeouts
    {
        public BasicHttpBinding();
        public BasicHttpBinding(BasicHttpSecurityMode securityMode);
        public bool EnableHttpCookieContainer { get; set; }
        public EnvelopeVersion EnvelopeVersion { get; }
        public int MaxBufferSize { get; set; }
        public long MaxReceivedMessageSize { get; set; }
        public BasicHttpSecurity Security { get; }
        public Encoding TextEncoding { get; set; }
        public override BindingElementCollection CreateBindingElements();
    }

    public sealed class BasicHttpSecurity
    {
        public BasicHttpSecurityMode Mode { get; set; }
    }

    public abstract class ChannelFactory: CommunicationObject, IChannelFactory, IDisposable
    {
        protected ChannelFactory();
        public ClientCredentials Credentials { get; }
        public ServiceEndpoint Endpoint { get; }
        protected virtual void ApplyConfiguration(string configurationName);
        protected abstract ServiceEndpoint CreateDescription();
        protected virtual IChannelFactory CreateFactory();
        protected void EnsureOpened();
        public T GetProperty<T>();
        protected void InitializeEndpoint(Binding binding, EndpointAddress address);
        protected void InitializeEndpoint(ServiceEndpoint endpoint);
        protected void InitializeEndpoint(string configurationName, EndpointAddress address);
        protected override void OnAbort();
        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state);
        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state);
        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();
    }

    public class ChannelFactory`1<TChannel>: ChannelFactory, IChannelFactory`1<TChannel>, IDisposable
    {
        public ChannelFactory`1(Binding binding, EndpointAddress remoteAddress);
        public ChannelFactory`1(string endpointConfigurationName);
        public ChannelFactory`1(string endpointConfigurationName, EndpointAddress remoteAddress);
        protected ChannelFactory`1(Type channelType);
        public TChannel CreateChannel();
        public TChannel CreateChannel(EndpointAddress address);
        public virtual TChannel CreateChannel(EndpointAddress address, Uri via);
        protected override ServiceEndpoint CreateDescription();
    }

    public abstract class ClientBase`1<TChannel>: ICommunicationObject
    {
        protected ClientBase`1();
        protected ClientBase`1(Binding binding, EndpointAddress remoteAddress);
        protected ClientBase`1(string endpointConfigurationName);
        protected ClientBase`1(string endpointConfigurationName, EndpointAddress remoteAddress);
        protected ClientBase`1(string endpointConfigurationName, string remoteAddress);
        protected TChannel Channel { get; }
        public ChannelFactory`1<TChannel> ChannelFactory { get; }
        public ClientCredentials ClientCredentials { get; }
        public ServiceEndpoint Endpoint { get; }
        public IClientChannel InnerChannel { get; }
        public CommunicationState State { get; }
        public void Abort();
        protected virtual TChannel CreateChannel();
        protected T GetDefaultValueForInitialization<T>();
        protected void InvokeAsync(BeginOperationDelegate<TChannel> beginOperationDelegate, object[] inValues, EndOperationDelegate<TChannel> endOperationDelegate, SendOrPostCallback operationCompletedCallback, object userState);
    }

    public class EndpointAddress
    {
        public EndpointAddress(string uri);
        public EndpointAddress(Uri uri, params AddressHeader[] addressHeaders);
        public static Uri AnonymousUri { get; }
        public AddressHeaderCollection Headers { get; }
        public bool IsAnonymous { get; }
        public bool IsNone { get; }
        public static Uri NoneUri { get; }
        public Uri Uri { get; }
        public void ApplyTo(Message message);
        public override bool Equals(object obj);
        public override int GetHashCode();
        public static EndpointAddress ReadFrom(AddressingVersion addressingVersion, XmlDictionaryReader reader);
        public override string ToString();
        public void WriteContentsTo(AddressingVersion addressingVersion, XmlDictionaryWriter writer);
        public static bool operator ==(EndpointAddress address1, EndpointAddress address2);
        public static bool operator !=(EndpointAddress address1, EndpointAddress address2);
    }

    public class EndpointAddressBuilder
    {
        public EndpointAddressBuilder();
        public EndpointAddressBuilder(EndpointAddress address);
        public Collection`1<AddressHeader> Headers { get; }
        public Uri Uri { get; set; }
        public EndpointAddress ToEndpointAddress();
    }

    public sealed class EnvelopeVersion
    {
        public string NextDestinationActorValue { get; }
        public static EnvelopeVersion None { get; }
        public static EnvelopeVersion Soap11 { get; }
        public static EnvelopeVersion Soap12 { get; }
        public string[] GetUltimateDestinationActorValues();
        public override string ToString();
    }

    [DataContractAttribute(..)]
    public class ExceptionDetail
    {
        public ExceptionDetail(Exception exception);
        public ExceptionDetail InnerException { get; set; }
        public string Message { get; set; }
        public string StackTrace { get; set; }
        public string Type { get; set; }
        public override string ToString();
    }

    public class FaultCode
    {
        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 bool IsPredefinedFault { get; }
        public bool IsReceiverFault { get; }
        public bool IsSenderFault { get; }
        public string Name { get; }
        public string Namespace { get; }
        public FaultCode SubCode { get; }
        public static FaultCode CreateSenderFaultCode(FaultCode subCode);
    }

    public class FaultReason
    {
        public FaultReason(FaultReasonText translation);
        public FaultReason(IEnumerable`1<FaultReasonText> translations);
        public FaultReason(string text);
        public SynchronizedReadOnlyCollection`1<FaultReasonText> Translations { get; }
        public FaultReasonText GetMatchingTranslation();
        public FaultReasonText GetMatchingTranslation(CultureInfo cultureInfo);
        public override string ToString();
    }

    public class FaultReasonText
    {
        public FaultReasonText(string text);
        public FaultReasonText(string text, string xmlLang);
        public string Text { get; }
        public string XmlLang { get; }
        public bool Matches(CultureInfo cultureInfo);
    }

    public interface IClientChannel: IContextChannel, IDisposable
    {
        public bool AllowInitializationUI { get; set; }
        public bool DidInteractiveInitialization { get; }
        public Uri Via { get; }
        public IAsyncResult BeginDisplayInitializationUI(AsyncCallback callback, object state);
        public void DisplayInitializationUI();
        public void EndDisplayInitializationUI(IAsyncResult result);
        public event EventHandler`1<UnknownMessageReceivedEventArgs> UnknownMessageReceived;
    }

    public interface ICommunicationObject
    {
        public CommunicationState State { get; }
        public void Abort();
        public IAsyncResult BeginClose(AsyncCallback callback, object state);
        public IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state);
        public IAsyncResult BeginOpen(AsyncCallback callback, object state);
        public IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, object state);
        public void Close();
        public void Close(TimeSpan timeout);
        public void EndClose(IAsyncResult result);
        public void EndOpen(IAsyncResult result);
        public void Open();
        public void Open(TimeSpan timeout);
        public event EventHandler Closed;
        public event EventHandler Closing;
        public event EventHandler Faulted;
        public event EventHandler Opened;
        public event EventHandler Opening;
    }

    public interface IContextChannel: IChannel, IExtensibleObject`1
    {
        public bool AllowOutputBatching { get; set; }
        public IInputSession InputSession { get; }
        public EndpointAddress LocalAddress { get; }
        public TimeSpan OperationTimeout { get; set; }
        public IOutputSession OutputSession { get; }
        public EndpointAddress RemoteAddress { get; }
        public string SessionId { get; }
    }

    public interface IDefaultCommunicationTimeouts
    {
        public TimeSpan CloseTimeout { get; }
        public TimeSpan OpenTimeout { get; }
        public TimeSpan ReceiveTimeout { get; }
        public TimeSpan SendTimeout { get; }
    }

    public interface IExtensibleObject`1<T> where T:IExtensibleObject`1<T>
    {
        public IExtensionCollection`1<T> Extensions { get; }
    }

    public interface IExtension`1<T> where T:IExtensibleObject`1<T>
    {
        public void Attach(T owner);
        public void Detach(T owner);
    }

    public sealed class OperationContext
    {
        public OperationContext(IContextChannel channel);
        public static OperationContext Current { get; set; }
        public MessageHeaders IncomingMessageHeaders { get; }
        public MessageProperties IncomingMessageProperties { get; }
        public MessageVersion IncomingMessageVersion { get; }
        public bool IsUserContext { get; }
        public MessageHeaders OutgoingMessageHeaders { get; }
        public MessageProperties OutgoingMessageProperties { get; }
        public RequestContext RequestContext { get; set; }
        public event EventHandler OperationCompleted;
    }

    public sealed class OperationContextScope: IDisposable
    {
        public OperationContextScope(IContextChannel channel);
        public OperationContextScope(OperationContext context);
        public void Dispose();
    }

    public enum BasicHttpMessageCredentialType
    {
        UserName,
    }

    public enum BasicHttpSecurityMode
    {
        None,
        Transport,
        TransportCredentialOnly,
        TransportWithMessageCredential,
    }

    public enum CommunicationState
    {
        Closed,
        Closing,
        Created,
        Faulted,
        Opened,
        Opening,
    }

    public enum OperationFormatStyle
    {
        Document,
        Rpc,
    }

    public interface IExtensionCollection`1<T>: ICollection`1<IExtension`1> where T:IExtensibleObject`1<T>
    {
        public E Find<E>();
        public Collection`1<E> FindAll<E>();
    }

    public sealed class UnknownMessageReceivedEventArgs: EventArgs
    {
        public Message Message { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class DataContractFormatAttribute: Attribute, _Attribute
    {
        public DataContractFormatAttribute();
        public OperationFormatStyle Style { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class FaultContractAttribute: Attribute, _Attribute
    {
        public FaultContractAttribute(Type detailType);
        public string Action { get; set; }
        public Type DetailType { get; }
        public string Name { get; set; }
        public string Namespace { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class MessageBodyMemberAttribute: MessageContractMemberAttribute, _Attribute
    {
        public MessageBodyMemberAttribute();
        public int Order { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class MessageContractAttribute: Attribute, _Attribute
    {
        public MessageContractAttribute();
        public bool IsWrapped { get; set; }
        public string WrapperName { get; set; }
        public string WrapperNamespace { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public abstract class MessageContractMemberAttribute: Attribute, _Attribute
    {
        protected MessageContractMemberAttribute();
        public string Name { get; set; }
        public string Namespace { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class MessageParameterAttribute: Attribute, _Attribute
    {
        public MessageParameterAttribute();
        public string Name { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class OperationContractAttribute: Attribute, _Attribute
    {
        public OperationContractAttribute();
        public string Action { get; set; }
        public bool AsyncPattern { get; set; }
        public bool IsOneWay { get; set; }
        public string Name { get; set; }
        public string ReplyAction { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class ServiceContractAttribute: Attribute, _Attribute
    {
        public ServiceContractAttribute();
        public Type CallbackContract { get; set; }
        public string ConfigurationName { get; set; }
        public string Name { get; set; }
        public string Namespace { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class ServiceKnownTypeAttribute: Attribute, _Attribute
    {
        public ServiceKnownTypeAttribute(string methodName);
        public ServiceKnownTypeAttribute(string methodName, Type declaringType);
        public ServiceKnownTypeAttribute(Type type);
        public Type DeclaringType { get; }
        public string MethodName { get; }
        public Type Type { get; }
    }

    public class ActionNotSupportedException: CommunicationException, _Exception, ISerializable
    {
        public ActionNotSupportedException(string message);
        public ActionNotSupportedException(string message, Exception innerException);
    }

    public class CommunicationException: SystemException, _Exception, ISerializable
    {
        public CommunicationException();
        public CommunicationException(string message);
        public CommunicationException(string message, Exception innerException);
    }

    public class CommunicationObjectAbortedException: CommunicationException, _Exception, ISerializable
    {
        public CommunicationObjectAbortedException(string message);
        public CommunicationObjectAbortedException(string message, Exception innerException);
    }

    public class CommunicationObjectFaultedException: CommunicationException, _Exception, ISerializable
    {
        public CommunicationObjectFaultedException(string message);
        public CommunicationObjectFaultedException(string message, Exception innerException);
    }

    public class EndpointNotFoundException: CommunicationException, _Exception, ISerializable
    {
        public EndpointNotFoundException(string message);
        public EndpointNotFoundException(string message, Exception innerException);
    }

    public class FaultException: CommunicationException, _Exception, ISerializable
    {
        public FaultException();
        public FaultException(FaultReason reason, FaultCode code, string action);
        public FaultException(MessageFault fault, string action);
        public string Action { get; }
        public FaultCode Code { get; }
        public FaultReason Reason { get; }
        public static FaultException CreateFault(MessageFault messageFault, string action, params Type[] faultDetailTypes);
        public static FaultException CreateFault(MessageFault messageFault, params Type[] faultDetailTypes);
        public virtual MessageFault CreateMessageFault();
    }

    public class FaultException`1<TDetail>: FaultException, _Exception, ISerializable
    {
        public FaultException`1(TDetail detail, FaultReason reason, FaultCode code, string action);
        public TDetail Detail { get; }
        public override string ToString();
    }

    public class InvalidMessageContractException: SystemException, _Exception, ISerializable
    {
        public InvalidMessageContractException();
        public InvalidMessageContractException(string message);
        public InvalidMessageContractException(string message, Exception innerException);
    }

    public class MessageHeaderException: ProtocolException, _Exception, ISerializable
    {
        public MessageHeaderException(string message);
        public MessageHeaderException(string message, bool isDuplicate);
        public MessageHeaderException(string message, Exception innerException);
        public MessageHeaderException(string message, string headerName, string ns);
        public MessageHeaderException(string message, string headerName, string ns, bool isDuplicate);
        public MessageHeaderException(string message, string headerName, string ns, bool isDuplicate, Exception innerException);
        public MessageHeaderException(string message, string headerName, string ns, Exception innerException);
        public string HeaderName { get; }
        public string HeaderNamespace { get; }
        public bool IsDuplicate { get; }
    }

    public class ProtocolException: CommunicationException, _Exception, ISerializable
    {
        public ProtocolException(string message);
        public ProtocolException(string message, Exception innerException);
    }

    public class QuotaExceededException: SystemException, _Exception, ISerializable
    {
        public QuotaExceededException(string message);
        public QuotaExceededException(string message, Exception innerException);
    }

    public class ServerTooBusyException: CommunicationException, _Exception, ISerializable
    {
        public ServerTooBusyException(string message);
        public ServerTooBusyException(string message, Exception innerException);
    }

    public class ServiceActivationException: CommunicationException, _Exception, ISerializable
    {
        public ServiceActivationException(string message);
        public ServiceActivationException(string message, Exception innerException);
    }

} 

namespace System.ServiceModel.Channels
{
    public abstract class AddressHeader
    {
        protected AddressHeader();
        public abstract string Name { get; }
        public abstract string Namespace { get; }
        public static AddressHeader CreateAddressHeader(string name, string ns, object value);
        public static AddressHeader CreateAddressHeader(string name, string ns, object value, XmlObjectSerializer serializer);
        public override bool Equals(object obj);
        public virtual XmlDictionaryReader GetAddressHeaderReader();
        public override int GetHashCode();
        public T GetValue<T>();
        public T GetValue<T>(XmlObjectSerializer serializer);
        protected abstract void OnWriteAddressHeaderContents(XmlDictionaryWriter writer);
        protected virtual void OnWriteStartAddressHeader(XmlDictionaryWriter writer);
        public MessageHeader ToMessageHeader();
        public void WriteAddressHeader(XmlDictionaryWriter writer);
        public void WriteAddressHeader(XmlWriter writer);
        public void WriteAddressHeaderContents(XmlDictionaryWriter writer);
        public void WriteStartAddressHeader(XmlDictionaryWriter writer);
    }

    public sealed class AddressingVersion
    {
        public static AddressingVersion None { get; }
        public static AddressingVersion WSAddressing10 { get; }
        public override string ToString();
    }

    public sealed class BinaryMessageEncodingBindingElement: MessageEncodingBindingElement
    {
        public BinaryMessageEncodingBindingElement();
        public override IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingContext context);
        public override BindingElement Clone();
        public override MessageEncoderFactory CreateMessageEncoderFactory();
    }

    public abstract class Binding: IDefaultCommunicationTimeouts
    {
        protected Binding();
        protected Binding(string name, string ns);
        public TimeSpan CloseTimeout { get; set; }
        public MessageVersion MessageVersion { get; }
        public string Name { get; set; }
        public string Namespace { get; set; }
        public TimeSpan OpenTimeout { get; set; }
        public TimeSpan ReceiveTimeout { get; set; }
        public abstract string Scheme { get; }
        public TimeSpan SendTimeout { get; set; }
        public virtual IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingParameterCollection parameters);
        public IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(params object[] parameters);
        public virtual bool CanBuildChannelFactory<TChannel>(BindingParameterCollection parameters);
        public bool CanBuildChannelFactory<TChannel>(params object[] parameters);
        public abstract BindingElementCollection CreateBindingElements();
        public T GetProperty<T>(BindingParameterCollection parameters);
    }

    public class BindingContext
    {
        public BindingContext(CustomBinding binding, BindingParameterCollection parameters);
        public CustomBinding Binding { get; }
        public BindingParameterCollection BindingParameters { get; }
        public BindingElementCollection RemainingBindingElements { get; }
        public IChannelFactory`1<TChannel> BuildInnerChannelFactory<TChannel>();
        public bool CanBuildInnerChannelFactory<TChannel>();
        public BindingContext Clone();
        public T GetInnerProperty<T>();
    }

    public abstract class BindingElement
    {
        protected BindingElement();
        protected BindingElement(BindingElement elementToBeCloned);
        public virtual IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingContext context);
        public virtual bool CanBuildChannelFactory<TChannel>(BindingContext context);
        public abstract BindingElement Clone();
        public abstract T GetProperty<T>(BindingContext context);
    }

    public abstract class BodyWriter
    {
        protected BodyWriter(bool isBuffered);
        public bool IsBuffered { get; }
        protected abstract void OnWriteBodyContents(XmlDictionaryWriter writer);
        public void WriteBodyContents(XmlDictionaryWriter writer);
    }

    public abstract class BufferManager
    {
        protected BufferManager();
        public abstract void Clear();
        public static BufferManager CreateBufferManager(long maxBufferPoolSize, int maxBufferSize);
        public abstract void ReturnBuffer(byte[] buffer);
        public abstract byte[] TakeBuffer(int bufferSize);
    }

    public abstract class ChannelBase: CommunicationObject, IChannel, IDefaultCommunicationTimeouts
    {
        protected ChannelBase(ChannelManagerBase channelManager);
        protected TimeSpan DefaultReceiveTimeout { get; }
        protected TimeSpan DefaultSendTimeout { get; }
        protected ChannelManagerBase Manager { get; }
        public virtual T GetProperty<T>();
    }

    public abstract class ChannelFactoryBase: ChannelManagerBase, IChannelFactory, IDefaultCommunicationTimeouts
    {
        protected ChannelFactoryBase();
        protected ChannelFactoryBase(IDefaultCommunicationTimeouts timeouts);
        public virtual T GetProperty<T>();
        protected override void OnAbort();
        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state);
        protected override void OnClose(TimeSpan timeout);
        protected override void OnEndClose(IAsyncResult result);
    }

    public abstract class ChannelFactoryBase`1<TChannel>: ChannelFactoryBase, IChannelFactory`1<TChannel>, IDefaultCommunicationTimeouts
    {
        protected ChannelFactoryBase`1();
        protected ChannelFactoryBase`1(IDefaultCommunicationTimeouts timeouts);
        public TChannel CreateChannel(EndpointAddress address);
        public TChannel CreateChannel(EndpointAddress address, Uri via);
        protected override void OnAbort();
        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state);
        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, ICommunicationObject, IDefaultCommunicationTimeouts
    {
        protected ChannelManagerBase();
        protected abstract TimeSpan DefaultReceiveTimeout { get; }
        protected abstract TimeSpan DefaultSendTimeout { get; }
    }

    public abstract class CommunicationObject: ICommunicationObject
    {
        protected CommunicationObject();
        protected CommunicationObject(object mutex);
        protected abstract TimeSpan DefaultCloseTimeout { get; }
        protected abstract TimeSpan DefaultOpenTimeout { get; }
        protected bool IsDisposed { get; }
        public CommunicationState State { get; }
        protected object ThisLock { get; }
        public void Abort();
        public IAsyncResult BeginClose(AsyncCallback callback, object state);
        public IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state);
        public IAsyncResult BeginOpen(AsyncCallback callback, object state);
        public IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, object state);
        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();
        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);
        protected void ThrowIfDisposed();
        protected void ThrowIfDisposedOrImmutable();
        protected void ThrowIfDisposedOrNotOpen();
        public event EventHandler Closed;
        public event EventHandler Closing;
        public event EventHandler Faulted;
        public event EventHandler Opened;
        public event EventHandler Opening;
    }

    public class CustomBinding: Binding, IDefaultCommunicationTimeouts
    {
        public CustomBinding();
        public CustomBinding(Binding binding);
        public CustomBinding(params BindingElement[] bindingElementsInTopDownChannelStackOrder);
        public CustomBinding(IEnumerable`1<BindingElement> bindingElementsInTopDownChannelStackOrder);
        public CustomBinding(string name, string ns, params BindingElement[] bindingElementsInTopDownChannelStackOrder);
        public BindingElementCollection Elements { get; }
        public override BindingElementCollection CreateBindingElements();
    }

    public abstract class FaultConverter
    {
        protected FaultConverter();
        public static FaultConverter GetDefaultFaultConverter(MessageVersion version);
        protected abstract bool OnTryCreateException(Message message, MessageFault fault, ref Exception exception);
        protected abstract bool OnTryCreateFaultMessage(Exception exception, ref Message message);
        public bool TryCreateException(Message message, MessageFault fault, ref Exception exception);
    }

    public class HttpCookieContainerBindingElement: BindingElement
    {
        public HttpCookieContainerBindingElement();
        protected HttpCookieContainerBindingElement(HttpCookieContainerBindingElement elementToBeCloned);
        public override IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingContext context);
        public override BindingElement Clone();
        public override T GetProperty<T>(BindingContext context);
    }

    public sealed class HttpRequestMessageProperty
    {
        public HttpRequestMessageProperty();
        public WebHeaderCollection Headers { get; }
        public string Method { get; set; }
        public static string Name { get; }
        public string QueryString { get; set; }
        public bool SuppressEntityBody { get; set; }
    }

    public sealed class HttpResponseMessageProperty
    {
        public HttpResponseMessageProperty();
        public WebHeaderCollection Headers { get; }
        public static string Name { get; }
        public HttpStatusCode StatusCode { get; set; }
        public string StatusDescription { get; set; }
    }

    public class HttpsTransportBindingElement: HttpTransportBindingElement
    {
        public HttpsTransportBindingElement();
        protected HttpsTransportBindingElement(HttpsTransportBindingElement elementToBeCloned);
        public override IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingContext context);
        public override BindingElement Clone();
    }

    public class HttpTransportBindingElement: TransportBindingElement
    {
        public HttpTransportBindingElement();
        protected HttpTransportBindingElement(HttpTransportBindingElement elementToBeCloned);
        public int MaxBufferSize { get; set; }
        public override IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingContext context);
        public override bool CanBuildChannelFactory<TChannel>(BindingContext context);
        public override BindingElement Clone();
        public override T GetProperty<T>(BindingContext context);
    }

    public interface IChannel: ICommunicationObject
    {
        public T GetProperty<T>();
    }

    public interface IChannelFactory: ICommunicationObject
    {
        public T GetProperty<T>();
    }

    public interface IChannelFactory`1<TChannel>: IChannelFactory
    {
        public TChannel CreateChannel(EndpointAddress to);
        public TChannel CreateChannel(EndpointAddress to, Uri via);
    }

    public interface IDuplexChannel: IInputChannel, IOutputChannel
    {
    }

    public interface IDuplexSession: IInputSession, IOutputSession
    {
        public IAsyncResult BeginCloseOutputSession(AsyncCallback callback, object state);
        public IAsyncResult BeginCloseOutputSession(TimeSpan timeout, AsyncCallback callback, object state);
        public void CloseOutputSession();
        public void CloseOutputSession(TimeSpan timeout);
        public void EndCloseOutputSession(IAsyncResult result);
    }

    public interface IDuplexSessionChannel: IDuplexChannel, ISessionChannel`1
    {
    }

    public interface IHttpCookieContainerManager
    {
        public CookieContainer CookieContainer { get; set; }
    }

    public interface IInputChannel: IChannel
    {
        public EndpointAddress LocalAddress { get; }
        public IAsyncResult BeginReceive(AsyncCallback callback, object state);
        public IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, object state);
        public IAsyncResult BeginTryReceive(TimeSpan timeout, AsyncCallback callback, object state);
        public IAsyncResult BeginWaitForMessage(TimeSpan timeout, AsyncCallback callback, object state);
        public Message EndReceive(IAsyncResult result);
        public bool EndTryReceive(IAsyncResult result, ref Message message);
        public bool EndWaitForMessage(IAsyncResult result);
        public Message Receive();
        public Message Receive(TimeSpan timeout);
        public bool TryReceive(TimeSpan timeout, ref Message message);
        public bool WaitForMessage(TimeSpan timeout);
    }

    public interface IInputSession: ISession
    {
    }

    public interface IInputSessionChannel: IInputChannel, ISessionChannel`1
    {
    }

    public interface IMessageProperty
    {
        public IMessageProperty CreateCopy();
    }

    public interface IOutputChannel: IChannel
    {
        public EndpointAddress RemoteAddress { get; }
        public Uri Via { get; }
        public IAsyncResult BeginSend(Message message, AsyncCallback callback, object state);
        public IAsyncResult BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state);
        public void EndSend(IAsyncResult result);
        public void Send(Message message);
        public void Send(Message message, TimeSpan timeout);
    }

    public interface IOutputSession: ISession
    {
    }

    public interface IOutputSessionChannel: IOutputChannel, ISessionChannel`1
    {
    }

    public interface IRequestChannel: IChannel
    {
        public EndpointAddress RemoteAddress { get; }
        public Uri Via { get; }
        public IAsyncResult BeginRequest(Message message, AsyncCallback callback, object state);
        public IAsyncResult BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state);
        public Message EndRequest(IAsyncResult result);
        public Message Request(Message message);
        public Message Request(Message message, TimeSpan timeout);
    }

    public interface IRequestSessionChannel: IRequestChannel, ISessionChannel`1
    {
    }

    public interface ISession
    {
        public string Id { get; }
    }

    public interface ISessionChannel`1<TSession> where TSession:ISession
    {
        public TSession Session { get; }
    }

    public sealed class LocalClientSecuritySettings
    {
        public LocalClientSecuritySettings();
        public TimeSpan MaxClockSkew { get; set; }
        public TimeSpan ReplayWindow { get; set; }
        public TimeSpan TimestampValidityDuration { get; set; }
        public LocalClientSecuritySettings Clone();
    }

    public abstract class Message: IDisposable
    {
        protected Message();
        public abstract MessageHeaders Headers { get; }
        protected bool IsDisposed { get; }
        public virtual bool IsEmpty { get; }
        public virtual bool IsFault { get; }
        public abstract MessageProperties Properties { get; }
        public MessageState State { get; }
        public abstract MessageVersion Version { get; }
        public void Close();
        public static Message CreateMessage(MessageVersion version, string action);
        public static Message CreateMessage(MessageVersion version, string action, BodyWriter body);
        public static Message CreateMessage(MessageVersion version, string action, object body);
        public static Message CreateMessage(MessageVersion version, string action, object body, XmlObjectSerializer serializer);
        public static Message CreateMessage(MessageVersion version, string action, XmlDictionaryReader body);
        public static Message CreateMessage(MessageVersion version, string action, XmlReader body);
        public T GetBody<T>();
        public T GetBody<T>(XmlObjectSerializer serializer);
        public string GetBodyAttribute(string localName, string ns);
        public XmlDictionaryReader GetReaderAtBodyContents();
        protected virtual void OnBodyToString(XmlDictionaryWriter writer);
        protected virtual void OnClose();
        protected virtual string OnGetBodyAttribute(string localName, string ns);
        protected virtual XmlDictionaryReader OnGetReaderAtBodyContents();
        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);
        public override string ToString();
        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
    {
        protected MessageBuffer();
        public abstract int BufferSize { get; }
        public virtual string MessageContentType { get; }
        public abstract void Close();
        public abstract Message CreateMessage();
        public virtual void WriteMessage(Stream stream);
    }

    public abstract class MessageEncoder
    {
        protected MessageEncoder();
        public abstract string ContentType { get; }
        public abstract string MediaType { get; }
        public abstract MessageVersion MessageVersion { get; }
        public virtual T GetProperty<T>();
        public virtual bool IsContentTypeSupported(string contentType);
        public Message ReadMessage(ArraySegment`1<byte> buffer, BufferManager bufferManager);
        public abstract Message ReadMessage(ArraySegment`1<byte> buffer, BufferManager bufferManager, string contentType);
        public Message ReadMessage(Stream stream, int maxSizeOfHeaders);
        public abstract Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType);
        public override string ToString();
        public ArraySegment`1<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager);
        public abstract ArraySegment`1<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset);
        public abstract void WriteMessage(Message message, Stream stream);
    }

    public abstract class MessageEncoderFactory
    {
        protected MessageEncoderFactory();
        public abstract MessageEncoder Encoder { get; }
        public abstract MessageVersion MessageVersion { get; }
        public virtual MessageEncoder CreateSessionEncoder();
    }

    public abstract class MessageEncodingBindingElement: BindingElement
    {
        protected MessageEncodingBindingElement();
        protected MessageEncodingBindingElement(MessageEncodingBindingElement elementToBeCloned);
        public abstract MessageVersion MessageVersion { get; set; }
        public abstract MessageEncoderFactory CreateMessageEncoderFactory();
        public override T GetProperty<T>(BindingContext context);
    }

    public abstract class MessageFault
    {
        protected MessageFault();
        public virtual string Actor { get; }
        public abstract FaultCode Code { get; }
        public abstract bool HasDetail { get; }
        public virtual string Node { get; }
        public abstract FaultReason Reason { get; }
        public static MessageFault CreateFault(Message message, int maxBufferSize);
        public T GetDetail<T>();
        public T GetDetail<T>(XmlObjectSerializer serializer);
        public XmlDictionaryReader GetReaderAtDetailContents();
        protected virtual XmlDictionaryReader OnGetReaderAtDetailContents();
        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
    {
        protected MessageHeader();
        public static MessageHeader CreateHeader(string name, string ns, object value);
        public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand);
        public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand, string actor);
        public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand, string actor, bool relay);
        public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer);
        public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand);
        public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand, string actor);
        public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay);
        public virtual bool IsMessageVersionSupported(MessageVersion messageVersion);
        protected abstract void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion);
        protected virtual void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion);
        public override string ToString();
        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
    {
        protected 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 MessageVersion
    {
        public AddressingVersion Addressing { get; }
        public static MessageVersion Default { get; }
        public EnvelopeVersion Envelope { get; }
        public static MessageVersion None { get; }
        public static MessageVersion Soap11 { get; }
        public static MessageVersion Soap12WSAddressing10 { get; }
        public static MessageVersion CreateVersion(EnvelopeVersion envelopeVersion);
        public static MessageVersion CreateVersion(EnvelopeVersion envelopeVersion, AddressingVersion addressingVersion);
        public override bool Equals(object obj);
        public override int GetHashCode();
        public override string ToString();
    }

    public abstract class RequestContext: IDisposable
    {
        protected RequestContext();
        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);
    }

    public abstract class SecurityBindingElement: BindingElement
    {
        public bool IncludeTimestamp { get; set; }
        public LocalClientSecuritySettings LocalClientSettings { get; }
        public override IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingContext context);
        protected abstract IChannelFactory`1<TChannel> BuildChannelFactoryCore<TChannel>(BindingContext context);
        public override bool CanBuildChannelFactory<TChannel>(BindingContext context);
        public static TransportSecurityBindingElement CreateUserNameOverTransportBindingElement();
        public override T GetProperty<T>(BindingContext context);
    }

    public sealed class TextMessageEncodingBindingElement: MessageEncodingBindingElement
    {
        public TextMessageEncodingBindingElement();
        public TextMessageEncodingBindingElement(MessageVersion messageVersion, Encoding writeEncoding);
        public Encoding WriteEncoding { get; set; }
        public override IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingContext context);
        public override BindingElement Clone();
        public override MessageEncoderFactory CreateMessageEncoderFactory();
    }

    public abstract class TransportBindingElement: BindingElement
    {
        protected TransportBindingElement();
        protected TransportBindingElement(TransportBindingElement elementToBeCloned);
        public bool ManualAddressing { get; set; }
        public virtual long MaxReceivedMessageSize { get; set; }
        public abstract string Scheme { get; }
        public override T GetProperty<T>(BindingContext context);
    }

    public sealed class TransportSecurityBindingElement: SecurityBindingElement
    {
        public TransportSecurityBindingElement();
        protected override IChannelFactory`1<TChannel> BuildChannelFactoryCore<TChannel>(BindingContext context);
        public override BindingElement Clone();
    }

    public enum MessageState
    {
        Closed,
        Copied,
        Created,
        Read,
        Written,
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public sealed class AddressHeaderCollection: ReadOnlyCollection`1, IList, IList`1
    {
        public AddressHeaderCollection();
        public AddressHeaderCollection(IEnumerable`1<AddressHeader> addressHeaders);
        public void AddHeadersTo(Message message);
        public AddressHeader[] FindAll(string name, string ns);
        public AddressHeader FindHeader(string name, string ns);
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class BindingElementCollection: Collection`1, IList, IList`1
    {
        public BindingElementCollection();
        public BindingElementCollection(BindingElement[] elements);
        public BindingElementCollection(IEnumerable`1<BindingElement> elements);
        public void AddRange(params BindingElement[] elements);
        public BindingElementCollection Clone();
        public bool Contains(Type bindingElementType);
        public T Find<T>();
        public Collection`1<T> FindAll<T>();
        protected override void InsertItem(int index, BindingElement item);
        public T Remove<T>();
        public Collection`1<T> RemoveAll<T>();
        protected override void SetItem(int index, BindingElement item);
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class BindingParameterCollection: KeyedByTypeCollection`1, IList, IList`1
    {
        public BindingParameterCollection();
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class ChannelParameterCollection: Collection`1, IList, IList`1
    {
        public ChannelParameterCollection();
        public ChannelParameterCollection(IChannel channel);
        protected virtual IChannel Channel { get; }
        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);
    }

    [DefaultMemberAttribute(..)]
    public sealed class MessageHeaders: IEnumerable`1
    {
        public MessageHeaders(MessageHeaders collection);
        public MessageHeaders(MessageVersion version);
        public MessageHeaders(MessageVersion version, int initialSize);
        public string Action { get; set; }
        public int Count { get; }
        public EndpointAddress FaultTo { get; set; }
        public EndpointAddress From { get; set; }
        public UniqueId MessageId { get; set; }
        public MessageVersion MessageVersion { get; }
        public UniqueId RelatesTo { get; set; }
        public EndpointAddress ReplyTo { get; set; }
        public Uri To { get; set; }
        public MessageHeaderInfo this[int index] { get; }
        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);
        public int FindHeader(string name, string ns, params string[] actors);
        public IEnumerator`1<MessageHeaderInfo> GetEnumerator();
        public T GetHeader<T>(int index);
        public T GetHeader<T>(int index, XmlObjectSerializer serializer);
        public T GetHeader<T>(string name, string ns);
        public T GetHeader<T>(string name, string ns, params string[] actors);
        public T GetHeader<T>(string name, string ns, XmlObjectSerializer serializer);
        public XmlDictionaryReader GetReaderAtHeader(int headerIndex);
        public bool HaveMandatoryHeadersBeenUnderstood();
        public bool HaveMandatoryHeadersBeenUnderstood(params string[] actors);
        public void Insert(int headerIndex, MessageHeader header);
        public void RemoveAll(string name, string ns);
        public void RemoveAt(int headerIndex);
        public void SetAction(XmlDictionaryString action);
        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);
    }

    [DefaultMemberAttribute(..)]
    public sealed class MessageProperties: IDictionary`2, IDisposable
    {
        public MessageProperties();
        public MessageProperties(MessageProperties properties);
        public bool AllowOutputBatching { get; set; }
        public int Count { get; }
        public MessageEncoder Encoder { get; set; }
        public bool IsFixedSize { get; }
        public bool IsReadOnly { get; }
        public ICollection`1<string> Keys { get; }
        public ICollection`1<object> Values { get; }
        public Uri Via { get; set; }
        public object this[string name] { get; set; }
        public void Add(string name, object property);
        public void Clear();
        public bool ContainsKey(string name);
        public void CopyProperties(MessageProperties properties);
        public void Dispose();
        public bool Remove(string name);
        public bool TryGetValue(string name, ref object value);
    }

} 

namespace System.ServiceModel.Configuration
{
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public abstract class BindingElementExtensionElement: ConfigurationElement, IDeserializationCallback, IDictionary, IDictionary`2, ISerializable
    {
        protected BindingElementExtensionElement();
        public abstract Type BindingElementType { get; }
        public virtual void ApplyConfiguration(BindingElement bindingElement);
        protected abstract BindingElement CreateBindingElement();
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public abstract class TransportElement: BindingElementExtensionElement, IDeserializationCallback, IDictionary, IDictionary`2, ISerializable
    {
        protected TransportElement();
        public long MaxReceivedMessageSize { get; }
        public override void ApplyConfiguration(BindingElement bindingElement);
        protected override BindingElement CreateBindingElement();
        protected abstract TransportBindingElement CreateDefaultBindingElement();
    }

} 

namespace System.ServiceModel.Description
{
    public class ClientCredentials
    {
        public ClientCredentials();
        protected ClientCredentials(ClientCredentials other);
        public UserNamePasswordClientCredential UserName { get; }
        public ClientCredentials Clone();
        protected virtual ClientCredentials CloneCore();
    }

    [DebuggerDisplayAttribute(..)]
    public class ContractDescription
    {
        public ContractDescription(string name);
        public ContractDescription(string name, string ns);
        public Type CallbackContractType { get; set; }
        public string ConfigurationName { get; set; }
        public Type ContractType { get; set; }
        public string Name { get; set; }
        public string Namespace { get; set; }
        public OperationDescriptionCollection Operations { get; }
    }

    [DebuggerDisplayAttribute(..)]
    public class FaultDescription
    {
        public FaultDescription(string action);
        public string Action { get; set; }
        public Type DetailType { get; set; }
        public string Name { get; set; }
        public string Namespace { get; set; }
    }

    public class MessageBodyDescription
    {
        public MessageBodyDescription();
        public MessagePartDescriptionCollection Parts { get; }
        public MessagePartDescription ReturnValue { get; set; }
        public string WrapperName { get; set; }
        public string WrapperNamespace { get; set; }
    }

    [DebuggerDisplayAttribute(..)]
    public class MessageDescription
    {
        public MessageDescription(string action, MessageDirection direction);
        public string Action { get; }
        public MessageBodyDescription Body { get; }
        public MessageDirection Direction { get; }
        public Type MessageType { get; set; }
    }

    [DebuggerDisplayAttribute(..)]
    public class MessagePartDescription
    {
        public MessagePartDescription(string name, string ns);
        public int Index { get; set; }
        public MemberInfo MemberInfo { get; set; }
        public string Name { get; }
        public string Namespace { get; }
        public Type Type { get; set; }
    }

    [DebuggerDisplayAttribute(..)]
    public class OperationDescription
    {
        public OperationDescription(string name, ContractDescription declaringContract);
        public MethodInfo BeginMethod { get; set; }
        public ContractDescription DeclaringContract { get; set; }
        public MethodInfo EndMethod { get; set; }
        public FaultDescriptionCollection Faults { get; }
        public bool IsOneWay { get; }
        public Collection`1<Type> KnownTypes { get; }
        public MessageDescriptionCollection Messages { get; }
        public string Name { get; }
        public MethodInfo SyncMethod { get; set; }
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerDisplayAttribute(..)]
    public class ServiceEndpoint
    {
        public ServiceEndpoint(ContractDescription contract);
        public ServiceEndpoint(ContractDescription contract, Binding binding, EndpointAddress address);
        public EndpointAddress Address { get; set; }
        public Binding Binding { get; set; }
        public ContractDescription Contract { get; }
        public string Name { get; set; }
    }

    public enum MessageDirection
    {
        Input,
        Output,
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class FaultDescriptionCollection: Collection`1, IList, IList`1
    {
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class MessageDescriptionCollection: Collection`1, IList, IList`1
    {
        public MessageDescription Find(string action);
        public Collection`1<MessageDescription> FindAll(string action);
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class MessagePartDescriptionCollection: KeyedCollection`2, IList, IList`1
    {
        protected override XmlQualifiedName GetKeyForItem(MessagePartDescription item);
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class OperationDescriptionCollection: Collection`1, IList, IList`1
    {
        public OperationDescription Find(string name);
        public Collection`1<OperationDescription> FindAll(string name);
        protected override void InsertItem(int index, OperationDescription item);
        protected override void SetItem(int index, OperationDescription item);
    }

} 

namespace System.ServiceModel.Dispatcher
{
    public sealed class ClientOperation
    {
        public ClientOperation(ClientRuntime parent, string name, string action);
        public ClientOperation(ClientRuntime parent, string name, string action, string replyAction);
        public string Action { get; }
        public MethodInfo BeginMethod { get; set; }
        public bool DeserializeReply { get; set; }
        public MethodInfo EndMethod { get; set; }
        public IClientMessageFormatter Formatter { get; set; }
        public bool IsInitiating { get; set; }
        public bool IsOneWay { get; set; }
        public bool IsTerminating { get; set; }
        public string Name { get; }
        public ClientRuntime Parent { get; }
        public string ReplyAction { get; }
        public bool SerializeRequest { get; set; }
        public MethodInfo SyncMethod { get; set; }
    }

    public sealed class ClientRuntime
    {
        public Type ContractClientType { get; set; }
        public string ContractName { get; }
        public string ContractNamespace { get; }
        public bool ManualAddressing { get; set; }
        public int MaxFaultSize { get; set; }
        public IClientOperationSelector OperationSelector { get; set; }
        public ClientOperation UnhandledClientOperation { get; }
        public Uri Via { get; set; }
    }

    public class FaultContractInfo
    {
        public FaultContractInfo(string action, Type detail);
        public string Action { get; }
        public Type Detail { get; }
    }

    public interface IClientMessageFormatter
    {
        public object DeserializeReply(Message message, object[] parameters);
        public Message SerializeRequest(MessageVersion messageVersion, object[] parameters);
    }

    public interface IClientOperationSelector
    {
        public bool AreParametersRequiredForSelection { get; }
        public string SelectOperation(MethodBase method, object[] parameters);
    }

    public interface IDispatchMessageFormatter
    {
        public void DeserializeRequest(Message message, object[] parameters);
        public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result);
    }

} 

namespace System.ServiceModel.Security
{
    public sealed class UserNamePasswordClientCredential
    {
        public string Password { get; set; }
        public string UserName { get; set; }
    }

    public class MessageSecurityException: CommunicationException, _Exception, ISerializable
    {
        public MessageSecurityException(string message);
        public MessageSecurityException(string message, Exception innerException);
    }

    public class SecurityAccessDeniedException: CommunicationException, _Exception, ISerializable
    {
        public SecurityAccessDeniedException(string message);
        public SecurityAccessDeniedException(string message, Exception innerException);
    }

} 

namespace System.Runtime.Serialization.Json
{
    public sealed class DataContractJsonSerializer
    {
        public DataContractJsonSerializer(Type type);
        public DataContractJsonSerializer(Type type, IEnumerable`1<Type> knownTypes);
        public ReadOnlyCollection`1<Type> KnownTypes { get; }
        public object ReadObject(Stream stream);
        public void WriteObject(Stream stream, object graph);
    }

} 

namespace System.Windows.Browser
{
    public sealed class BrowserInformation
    {
        public Version BrowserVersion { get; }
        public bool CookiesEnabled { get; }
        public string Name { get; }
        public string Platform { get; }
        public string UserAgent { get; }
    }

    public sealed class HtmlDocument: HtmlObject, IDynamicMetaObjectProvider
    {
        public HtmlElement Body { get; }
        public string Cookies { get; set; }
        public HtmlElement DocumentElement { get; }
        public Uri DocumentUri { get; }
        public bool IsReady { get; }
        public IDictionary`2<string,string> QueryString { get; }
        public HtmlElement CreateElement(string tagName);
        public HtmlElement GetElementById(string id);
        public ScriptObjectCollection GetElementsByTagName(string tagName);
        public void Submit();
        public void Submit(string formId);
        public event EventHandler DocumentReady;
    }

    public sealed class HtmlElement: HtmlObject, IDynamicMetaObjectProvider
    {
        public ScriptObjectCollection Children { get; }
        public string CssClass { get; set; }
        public string Id { get; set; }
        public HtmlElement Parent { get; }
        public string TagName { get; }
        public void AppendChild(HtmlElement element);
        public void AppendChild(HtmlElement element, HtmlElement referenceElement);
        public void Focus();
        public string GetAttribute(string name);
        public string GetStyleAttribute(string name);
        public void RemoveAttribute(string name);
        public void RemoveChild(HtmlElement element);
        public void RemoveStyleAttribute(string name);
        public void SetAttribute(string name, string value);
        public void SetStyleAttribute(string name, string value);
    }

    public abstract class HtmlObject: ScriptObject, IDynamicMetaObjectProvider
    {
        protected HtmlObject();
        public bool AttachEvent(string eventName, EventHandler handler);
        public bool AttachEvent(string eventName, EventHandler`1<HtmlEventArgs> handler);
        protected override object ConvertTo(Type targetType, bool allowSerialization);
        public void DetachEvent(string eventName, EventHandler handler);
        public void DetachEvent(string eventName, EventHandler`1<HtmlEventArgs> handler);
    }

    public abstract sealed class HtmlPage
    {
        public static BrowserInformation BrowserInformation { get; }
        public static HtmlDocument Document { get; }
        public static bool IsEnabled { get; }
        public static bool IsPopupWindowAllowed { get; }
        public static HtmlElement Plugin { get; }
        public static HtmlWindow Window { get; }
        public static HtmlWindow PopupWindow(Uri navigateToUri, string target, HtmlPopupWindowOptions options);
        public static void RegisterCreateableType(string scriptAlias, Type type);
        public static void RegisterScriptableObject(string scriptKey, object instance);
        public static void UnregisterCreateableType(string scriptAlias);
    }

    public sealed class HtmlPopupWindowOptions
    {
        public HtmlPopupWindowOptions();
        public bool Directories { get; set; }
        public int Height { get; set; }
        public int Left { get; set; }
        public bool Location { get; set; }
        public bool Menubar { get; set; }
        public bool Resizeable { get; set; }
        public bool Scrollbars { get; set; }
        public bool Status { get; set; }
        public bool Toolbar { get; set; }
        public int Top { get; set; }
        public int Width { get; set; }
    }

    public sealed class HtmlWindow: HtmlObject, IDynamicMetaObjectProvider
    {
        public string CurrentBookmark { get; set; }
        public void Alert(string alertText);
        public bool Confirm(string confirmText);
        public ScriptObject CreateInstance(string typeName, params object[] args);
        public object Eval(string code);
        public void Navigate(Uri navigateToUri);
        public HtmlWindow Navigate(Uri navigateToUri, string target);
        public HtmlWindow Navigate(Uri navigateToUri, string target, string targetFeatures);
        public void NavigateToBookmark(string bookmark);
        public string Prompt(string promptText);
    }

    [SecuritySafeCriticalAttribute(..)]
    public abstract sealed class HttpUtility
    {
        public static string HtmlDecode(string html);
        public static string HtmlEncode(string html);
        public static string UrlDecode(string url);
        public static string UrlEncode(string url);
    }

    public class ScriptObject: IDynamicMetaObjectProvider
    {
        public Dispatcher Dispatcher { get; }
        public object ManagedObject { get; }
        public bool CheckAccess();
        public T ConvertTo<T>();
        protected virtual object ConvertTo(Type targetType, bool allowSerialization);
        protected override void Finalize();
        public object GetProperty(int index);
        public virtual object GetProperty(string name);
        protected void Initialize(IntPtr handle, IntPtr identity, bool addReference, bool releaseReferenceOnDispose);
        public virtual object Invoke(string name, params object[] args);
        public virtual object InvokeSelf(params object[] args);
        public void SetProperty(int index, object value);
        public virtual void SetProperty(string name, object value);
    }

    [FlagsAttribute(..)]
    public enum MouseButtons
    {
        Left,
        Middle,
        None,
        Right,
    }

    [DefaultMemberAttribute(..)]
    public sealed class ScriptObjectCollection: ScriptObject, IDynamicMetaObjectProvider, IEnumerable`1
    {
        public int Count { get; }
        public ScriptObject this[int index] { get; }
    }

    public class HtmlEventArgs: EventArgs
    {
        public bool AltKey { get; }
        public int CharacterCode { get; }
        public int ClientX { get; }
        public int ClientY { get; }
        public bool CtrlKey { get; }
        public ScriptObject EventObject { get; }
        public string EventType { get; }
        public int KeyCode { get; }
        public MouseButtons MouseButton { get; }
        public int OffsetX { get; }
        public int OffsetY { get; }
        public int ScreenX { get; }
        public int ScreenY { get; }
        public bool ShiftKey { get; }
        public HtmlObject Source { get; }
        public void PreventDefault();
        public void StopPropagation();
    }

    public delegate void ScriptEventHandler(ScriptObject sender, ScriptObject args);

    [AttributeUsageAttribute(..)]
    public sealed class ScriptableMemberAttribute: Attribute, _Attribute
    {
        public ScriptableMemberAttribute();
        public bool EnableCreateableTypes { get; set; }
        public string ScriptAlias { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class ScriptableTypeAttribute: Attribute, _Attribute
    {
        public ScriptableTypeAttribute();
    }

} 

namespace Microsoft.Internal
{
    [ComVisibleAttribute(..)]
    [GuidAttribute(..)]
    [InterfaceTypeAttribute(..)]
    public interface IManagedFrameworkInternalHelper
    {
        [SecurityCriticalAttribute(..)]
        public void SetContextEx(IntPtr context);
    }

} 

namespace MS.Internal.ComAutomation
{
    public sealed class ComAutomationParam
    {
        public ComAutomationParam();
        public ComAutomationParam(object value, bool byRef);
        public bool ByRef { get; set; }
        public object Value { get; set; }
    }

} 

namespace System.Collections.ObjectModel
{
    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class ObservableCollection`1<T>: Collection`1, IList, IList`1<T>, INotifyCollectionChanged, INotifyPropertyChanged
    {
        public ObservableCollection`1();
        public ObservableCollection`1(IEnumerable`1<T> collection);
        public ObservableCollection`1(List`1<T> list);
        protected override void ClearItems();
        protected override void InsertItem(int index, T item);
        protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e);
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e);
        protected override void RemoveItem(int index);
        protected override void SetItem(int index, T item);
        public event NotifyCollectionChangedEventHandler CollectionChanged;
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class ReadOnlyObservableCollection`1<T>: ReadOnlyCollection`1, IList, IList`1<T>, INotifyCollectionChanged, INotifyPropertyChanged
    {
        public ReadOnlyObservableCollection`1(ObservableCollection`1<T> list);
        protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs args);
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs args);
    }

} 

namespace System.Collections.Specialized
{
    public interface INotifyCollectionChanged
    {
        public event NotifyCollectionChangedEventHandler CollectionChanged;
    }

    public enum NotifyCollectionChangedAction
    {
        Add,
        Remove,
        Replace,
        Reset,
    }

    public sealed class NotifyCollectionChangedEventArgs: EventArgs
    {
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action);
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem, int index);
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object newItem, object oldItem, int index);
        public NotifyCollectionChangedAction Action { get; }
        public IList NewItems { get; }
        public int NewStartingIndex { get; }
        public IList OldItems { get; }
        public int OldStartingIndex { get; }
    }

    public delegate void NotifyCollectionChangedEventHandler(object sender, NotifyCollectionChangedEventArgs e);

} 

namespace System.ComponentModel
{
    public abstract sealed class DesignerProperties
    {
        public static readonly DependencyProperty IsInDesignModeProperty;
        public static bool IsInDesignTool { get; set; }
        public static bool GetIsInDesignMode(DependencyObject element);
        public static void SetIsInDesignMode(DependencyObject element, bool value);
    }

    public abstract class GroupDescription: INotifyPropertyChanged
    {
        protected GroupDescription();
        public ObservableCollection`1<object> GroupNames { get; }
        public abstract object GroupNameFromItem(object item, int level, CultureInfo culture);
        public virtual bool NamesMatch(object groupName, object itemName);
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e);
        public bool ShouldSerializeGroupNames();
    }

    public interface IEditableCollectionView
    {
        public bool CanAddNew { get; }
        public bool CanCancelEdit { get; }
        public bool CanRemove { get; }
        public object CurrentAddItem { get; }
        public object CurrentEditItem { get; }
        public bool IsAddingNew { get; }
        public bool IsEditingItem { get; }
        public NewItemPlaceholderPosition NewItemPlaceholderPosition { get; set; }
        public object AddNew();
        public void CancelEdit();
        public void CancelNew();
        public void CommitEdit();
        public void CommitNew();
        public void EditItem(object item);
        public void Remove(object item);
        public void RemoveAt(int index);
    }

    public struct SortDescription
    {
        public SortDescription(string propertyName, ListSortDirection direction);
        public ListSortDirection Direction { get; set; }
        public bool IsSealed { get; }
        public string PropertyName { get; set; }
        public override bool Equals(object obj);
        public override int GetHashCode();
        public static bool operator ==(SortDescription sd1, SortDescription sd2);
        public static bool operator !=(SortDescription sd1, SortDescription sd2);
    }

    public enum NewItemPlaceholderPosition
    {
        None,
    }

    public interface ICollectionView: IEnumerable, INotifyCollectionChanged
    {
        public bool CanFilter { get; }
        public bool CanGroup { get; }
        public bool CanSort { get; }
        public CultureInfo Culture { get; set; }
        public object CurrentItem { get; }
        public int CurrentPosition { get; }
        public Predicate`1<object> Filter { get; set; }
        public ObservableCollection`1<GroupDescription> GroupDescriptions { get; }
        public ReadOnlyObservableCollection`1<object> Groups { get; }
        public bool IsCurrentAfterLast { get; }
        public bool IsCurrentBeforeFirst { get; }
        public bool IsEmpty { get; }
        public SortDescriptionCollection SortDescriptions { get; }
        public IEnumerable SourceCollection { get; }
        public bool Contains(object item);
        public IDisposable DeferRefresh();
        public bool MoveCurrentTo(object item);
        public bool MoveCurrentToFirst();
        public bool MoveCurrentToLast();
        public bool MoveCurrentToNext();
        public bool MoveCurrentToPosition(int position);
        public bool MoveCurrentToPrevious();
        public void Refresh();
        public event EventHandler CurrentChanged;
        public event CurrentChangingEventHandler CurrentChanging;
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class SortDescriptionCollection: Collection`1, IList, IList`1, INotifyCollectionChanged
    {
        public SortDescriptionCollection();
        public static readonly SortDescriptionCollection Empty;
        protected override void ClearItems();
        protected override void InsertItem(int index, SortDescription item);
        protected override void RemoveItem(int index);
        protected override void SetItem(int index, SortDescription item);
    }

    public class CurrentChangingEventArgs: EventArgs
    {
        public CurrentChangingEventArgs();
        public CurrentChangingEventArgs(bool isCancelable);
        public bool Cancel { get; set; }
        public bool IsCancelable { get; }
    }

    public delegate void CurrentChangingEventHandler(object sender, CurrentChangingEventArgs e);

} 

namespace System.IO.IsolatedStorage
{
    [DefaultMemberAttribute(..)]
    public sealed class IsolatedStorageSettings: IDictionary, IDictionary`2
    {
        public static IsolatedStorageSettings ApplicationSettings { get; }
        public int Count { get; }
        public ICollection Keys { get; }
        public static IsolatedStorageSettings SiteSettings { get; }
        public ICollection Values { get; }
        public object this[string key] { get; set; }
        public void Add(string key, object value);
        public void Clear();
        public bool Contains(string key);
        protected override void Finalize();
        public bool Remove(string key);
        public void Save();
        public bool TryGetValue<T>(string key, ref T value);
    }

} 

namespace System.Net.Browser
{
    public abstract sealed class WebRequestCreator
    {
        public static IWebRequestCreate BrowserHttp { get; }
        public static IWebRequestCreate ClientHttp { get; }
    }

} 

namespace System.Windows
{
    public class Analytics
    {
        public Analytics();
        public float AverageProcessLoad { get; }
        public float AverageProcessorLoad { get; }
        public ReadOnlyCollection`1<GpuInformation> GpuCollection { get; }
        protected override void Finalize();
    }

    public class Application
    {
        public Application();
        public IList ApplicationLifetimeObjects { get; }
        public static Application Current { get; }
        public bool HasElevatedPermissions { get; set; }
        public SilverlightHost Host { get; }
        public InstallState InstallState { get; }
        public bool IsRunningOutOfBrowser { get; }
        public Window MainWindow { get; }
        public ResourceDictionary Resources { get; set; }
        public UIElement RootVisual { get; set; }
        public void CheckAndDownloadUpdateAsync();
        public static StreamResourceInfo GetResourceStream(StreamResourceInfo zipPackageStreamResourceInfo, Uri uriResource);
        public static StreamResourceInfo GetResourceStream(Uri uriResource);
        public bool Install();
        public static void LoadComponent(object component, Uri resourceLocator);
        public event CheckAndDownloadUpdateCompletedEventHandler CheckAndDownloadUpdateCompleted;
        public event EventHandler Exit;
        public event EventHandler InstallStateChanged;
        public event StartupEventHandler Startup;
        public event EventHandler`1<ApplicationUnhandledExceptionEventArgs> UnhandledException;
    }

    public class ApplicationServiceContext
    {
        public Dictionary`2<string,string> ApplicationInitParams { get; }
    }

    public sealed class AssemblyPart: DependencyObject
    {
        public AssemblyPart();
        public static readonly DependencyProperty SourceProperty;
        public string Source { get; set; }
        public Assembly Load(Stream assemblyStream);
    }

    public abstract sealed class Clipboard
    {
        public static bool ContainsText();
        public static string GetText();
        public static void SetText(string text);
    }

    public struct CornerRadius
    {
        public CornerRadius(double uniformRadius);
        public CornerRadius(double topLeft, double topRight, double bottomRight, double bottomLeft);
        public double BottomLeft { get; set; }
        public double BottomRight { get; set; }
        public double TopLeft { get; set; }
        public double TopRight { get; set; }
        public bool Equals(CornerRadius cornerRadius);
        public override bool Equals(object obj);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(CornerRadius cr1, CornerRadius cr2);
        public static bool operator !=(CornerRadius cr1, CornerRadius cr2);
    }

    public abstract sealed class DataFormats
    {
        public static readonly string FileDrop;
    }

    public sealed class DataObject: IDataObject
    {
        public DataObject();
        public DataObject(object data);
        public object GetData(string format);
        public object GetData(string format, bool autoConvert);
        public object GetData(Type format);
        public bool GetDataPresent(string format);
        public bool GetDataPresent(string format, bool autoConvert);
        public bool GetDataPresent(Type format);
        public string[] GetFormats();
        public string[] GetFormats(bool autoConvert);
        public void SetData(object data);
        public void SetData(string format, object data);
        public void SetData(string format, object data, bool autoConvert);
        public void SetData(Type format, object data);
    }

    public class DataTemplate: FrameworkTemplate
    {
        public DataTemplate();
        public DependencyObject LoadContent();
    }

    public abstract class DependencyObject
    {
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        protected DependencyObject();
        public Dispatcher Dispatcher { get; }
        public bool CheckAccess();
        public void ClearValue(DependencyProperty dp);
        public object GetAnimationBaseValue(DependencyProperty dp);
        public object GetValue(DependencyProperty dp);
        public object ReadLocalValue(DependencyProperty dp);
        public void SetValue(DependencyProperty dp, object value);
    }

    public class DependencyProperty
    {
        public static readonly object UnsetValue;
        public PropertyMetadata GetMetadata(Type forType);
        public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata);
        public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata);
    }

    public struct DependencyPropertyChangedEventArgs
    {
        public object NewValue { get; }
        public object OldValue { get; }
        public DependencyProperty Property { get; }
    }

    public sealed class Deployment: DependencyObject
    {
        public Deployment();
        public static readonly DependencyProperty EntryPointAssemblyProperty;
        public static readonly DependencyProperty EntryPointTypeProperty;
        public static readonly DependencyProperty ExternalCallersFromCrossDomainProperty;
        public static readonly DependencyProperty ExternalPartsProperty;
        public static readonly DependencyProperty OutOfBrowserSettingsProperty;
        public static readonly DependencyProperty PartsProperty;
        public static readonly DependencyProperty RuntimeVersionProperty;
        public static Deployment Current { get; }
        public string EntryPointAssembly { get; }
        public string EntryPointType { get; }
        public CrossDomainAccess ExternalCallersFromCrossDomain { get; }
        public ExternalPartCollection ExternalParts { get; }
        public OutOfBrowserSettings OutOfBrowserSettings { get; }
        public AssemblyPartCollection Parts { get; }
        public string RuntimeVersion { get; }
        [SecurityCriticalAttribute(..)]
        public static string GetAppIdForUri(Uri AppUri, ref string xapLocationStr);
        [SecurityCriticalAttribute(..)]
        public static void RegisterAssembly(Assembly assembly);
        [SecurityCriticalAttribute(..)]
        public static void SetCurrentApplication(Application application);
    }

    public struct Duration
    {
        public Duration(TimeSpan timeSpan);
        public static Duration Automatic { get; }
        public static Duration Forever { get; }
        public bool HasTimeSpan { get; }
        public TimeSpan TimeSpan { get; }
        public Duration Add(Duration duration);
        public static int Compare(Duration t1, Duration t2);
        public bool Equals(Duration duration);
        public static bool Equals(Duration t1, Duration t2);
        public override bool Equals(object value);
        public override int GetHashCode();
        public static Duration Plus(Duration duration);
        public Duration Subtract(Duration duration);
        public override string ToString();
        public static Duration operator +(Duration duration);
        public static Duration operator +(Duration t1, Duration t2);
        public static Duration operator -(Duration t1, Duration t2);
        public static bool operator ==(Duration t1, Duration t2);
        public static bool operator !=(Duration t1, Duration t2);
        public static bool operator >=(Duration t1, Duration t2);
        public static bool operator <=(Duration t1, Duration t2);
        public static bool operator >(Duration t1, Duration t2);
        public static bool operator <(Duration t1, Duration t2);
        public static implicit operator Duration(TimeSpan timeSpan);
    }

    public class DurationConverter: TypeConverter
    {
        public DurationConverter();
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
    }

    [ContentPropertyAttribute(..)]
    public sealed class EventTrigger: TriggerBase
    {
        public EventTrigger();
        public TriggerActionCollection Actions { get; }
        public RoutedEvent RoutedEvent { get; set; }
    }

    public abstract class Expression
    {
    }

    public sealed class ExtensionPart: ExternalPart
    {
        public ExtensionPart();
        public static readonly DependencyProperty SourceProperty;
        public Uri Source { get; set; }
    }

    public class ExternalPart: DependencyObject
    {
        public ExternalPart();
    }

    public struct FontStretch
    {
        public override bool Equals(object obj);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(FontStretch left, FontStretch right);
        public static bool operator !=(FontStretch left, FontStretch right);
    }

    public abstract sealed class FontStretches
    {
        public static FontStretch Condensed { get; }
        public static FontStretch Expanded { get; }
        public static FontStretch ExtraCondensed { get; }
        public static FontStretch ExtraExpanded { get; }
        public static FontStretch Normal { get; }
        public static FontStretch SemiCondensed { get; }
        public static FontStretch SemiExpanded { get; }
        public static FontStretch UltraCondensed { get; }
        public static FontStretch UltraExpanded { get; }
    }

    public struct FontStyle
    {
        public override bool Equals(object obj);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(FontStyle left, FontStyle right);
        public static bool operator !=(FontStyle left, FontStyle right);
    }

    public abstract sealed class FontStyles
    {
        public static FontStyle Italic { get; }
        public static FontStyle Normal { get; }
    }

    public struct FontWeight
    {
        public override bool Equals(object obj);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(FontWeight left, FontWeight right);
        public static bool operator !=(FontWeight left, FontWeight right);
    }

    public abstract sealed class FontWeights
    {
        public static FontWeight Black { get; }
        public static FontWeight Bold { get; }
        public static FontWeight ExtraBlack { get; }
        public static FontWeight ExtraBold { get; }
        public static FontWeight ExtraLight { get; }
        public static FontWeight Light { get; }
        public static FontWeight Medium { get; }
        public static FontWeight Normal { get; }
        public static FontWeight SemiBold { get; }
        public static FontWeight Thin { get; }
    }

    public abstract class FrameworkElement: UIElement
    {
        [SecurityCriticalAttribute(..)]
        protected FrameworkElement();
        public static readonly DependencyProperty ActualHeightProperty;
        public static readonly DependencyProperty ActualWidthProperty;
        public static readonly DependencyProperty DataContextProperty;
        public static readonly DependencyProperty FlowDirectionProperty;
        public static readonly DependencyProperty HeightProperty;
        public static readonly DependencyProperty HorizontalAlignmentProperty;
        public static readonly DependencyProperty LanguageProperty;
        public static readonly RoutedEvent LoadedEvent;
        public static readonly DependencyProperty MarginProperty;
        public static readonly DependencyProperty MaxHeightProperty;
        public static readonly DependencyProperty MaxWidthProperty;
        public static readonly DependencyProperty MinHeightProperty;
        public static readonly DependencyProperty MinWidthProperty;
        public static readonly DependencyProperty NameProperty;
        public static readonly DependencyProperty StyleProperty;
        public static readonly DependencyProperty TagProperty;
        public static readonly DependencyProperty VerticalAlignmentProperty;
        public static readonly DependencyProperty WidthProperty;
        public double ActualHeight { get; }
        public double ActualWidth { get; }
        public Cursor Cursor { get; set; }
        public object DataContext { get; set; }
        public FlowDirection FlowDirection { get; set; }
        public double Height { get; set; }
        public HorizontalAlignment HorizontalAlignment { get; set; }
        public XmlLanguage Language { get; set; }
        public Thickness Margin { get; set; }
        public double MaxHeight { get; set; }
        public double MaxWidth { get; set; }
        public double MinHeight { get; set; }
        public double MinWidth { get; set; }
        public string Name { get; set; }
        public DependencyObject Parent { get; }
        public ResourceDictionary Resources { get; set; }
        public Style Style { get; set; }
        public object Tag { get; set; }
        public TriggerCollection Triggers { get; }
        public VerticalAlignment VerticalAlignment { get; set; }
        public double Width { get; set; }
        protected virtual Size ArrangeOverride(Size finalSize);
        public object FindName(string name);
        public BindingExpression GetBindingExpression(DependencyProperty dp);
        protected virtual Size MeasureOverride(Size availableSize);
        public virtual void OnApplyTemplate();
        public BindingExpressionBase SetBinding(DependencyProperty dp, Binding binding);
        public event EventHandler`1<ValidationErrorEventArgs> BindingValidationError;
        public event EventHandler LayoutUpdated;
        public event RoutedEventHandler Loaded;
        public event SizeChangedEventHandler SizeChanged;
    }

    public abstract class FrameworkTemplate: DependencyObject
    {
        protected FrameworkTemplate();
    }

    public class GpuInformation
    {
        public int DeviceId { get; set; }
        public string DriverVersion { get; set; }
        public int VendorId { get; set; }
    }

    public struct GridLength
    {
        public GridLength(double pixels);
        public GridLength(double value, GridUnitType type);
        public static GridLength Auto { get; }
        public GridUnitType GridUnitType { get; }
        public bool IsAbsolute { get; }
        public bool IsAuto { get; }
        public bool IsStar { get; }
        public double Value { get; }
        public bool Equals(GridLength gridLength);
        public override bool Equals(object oCompare);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(GridLength gl1, GridLength gl2);
        public static bool operator !=(GridLength gl1, GridLength gl2);
    }

    public interface IApplicationLifetimeAware
    {
        public void Exited();
        public void Exiting();
        public void Started();
        public void Starting();
    }

    public interface IApplicationService
    {
        public void StartService(ApplicationServiceContext context);
        public void StopService();
    }

    public sealed class Icon: DependencyObject
    {
        public Icon();
        public static readonly DependencyProperty SizeProperty;
        public static readonly DependencyProperty SourceProperty;
        public Size Size { get; }
        public Uri Source { get; }
    }

    public interface IDataObject
    {
        public object GetData(string format);
        public object GetData(string format, bool autoConvert);
        public object GetData(Type format);
        public bool GetDataPresent(string format);
        public bool GetDataPresent(string format, bool autoConvert);
        public bool GetDataPresent(Type format);
        public string[] GetFormats();
        public string[] GetFormats(bool autoConvert);
        public void SetData(object data);
        public void SetData(string format, object data);
        public void SetData(string format, object data, bool autoConvert);
        public void SetData(Type format, object data);
    }

    public sealed class MessageBox
    {
        public static MessageBoxResult Show(string messageBoxText);
        public static MessageBoxResult Show(string messageBoxText, string caption, MessageBoxButton button);
    }

    public sealed class NotificationWindow: DependencyObject
    {
        public NotificationWindow();
        public static readonly DependencyProperty ContentProperty;
        public static readonly DependencyProperty HeightProperty;
        public static readonly DependencyProperty WidthProperty;
        public FrameworkElement Content { get; set; }
        public double Height { get; set; }
        public bool Visible { get; }
        public double Width { get; set; }
        public void Close();
        public void Show(int durationInMilliseconds);
        public event EventHandler`1<EventArgs> Closed;
    }

    public sealed class NullableBoolConverter: TypeConverter
    {
        public NullableBoolConverter();
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
    }

    public sealed class OutOfBrowserSettings: DependencyObject
    {
        public OutOfBrowserSettings();
        public static readonly DependencyProperty BlurbProperty;
        public static readonly DependencyProperty EnableGPUAccelerationProperty;
        public static readonly DependencyProperty IconsProperty;
        public static readonly DependencyProperty SecuritySettingsProperty;
        public static readonly DependencyProperty ShortNameProperty;
        public static readonly DependencyProperty ShowInstallMenuItemProperty;
        public static readonly DependencyProperty WindowSettingsProperty;
        public string Blurb { get; }
        public bool EnableGPUAcceleration { get; }
        public IconCollection Icons { get; }
        public SecuritySettings SecuritySettings { get; }
        public string ShortName { get; }
        public bool ShowInstallMenuItem { get; }
        public WindowSettings WindowSettings { get; }
    }

    public struct Point: IFormattable
    {
        public Point(double x, double y);
        public double X { get; set; }
        public double Y { get; set; }
        public override bool Equals(object o);
        public bool Equals(Point value);
        public override int GetHashCode();
        public override string ToString();
        public string ToString(IFormatProvider provider);
        public static bool operator ==(Point point1, Point point2);
        public static bool operator !=(Point point1, Point point2);
    }

    public class PropertyMetadata
    {
        public PropertyMetadata(object defaultValue);
        public PropertyMetadata(object defaultValue, PropertyChangedCallback propertyChangedCallback);
        public PropertyMetadata(PropertyChangedCallback propertyChangedCallback);
        public object DefaultValue { get; }
    }

    public sealed class PropertyPath
    {
        public PropertyPath(object parameter);
        public PropertyPath(string path, params object[] pathParameters);
        public string Path { get; set; }
    }

    public class PropertyPathConverter: TypeConverter
    {
        public PropertyPathConverter();
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
    }

    public struct Rect: IFormattable
    {
        public Rect(double x, double y, double width, double height);
        public Rect(Point point1, Point point2);
        public Rect(Point location, Size size);
        public double Bottom { get; }
        public static Rect Empty { get; }
        public double Height { get; set; }
        public bool IsEmpty { get; }
        public double Left { get; }
        public double Right { get; }
        public double Top { get; }
        public double Width { get; set; }
        public double X { get; set; }
        public double Y { get; set; }
        public bool Contains(Point point);
        public override bool Equals(object o);
        public bool Equals(Rect value);
        public override int GetHashCode();
        public void Intersect(Rect rect);
        public override string ToString();
        public string ToString(IFormatProvider provider);
        public void Union(Point point);
        public void Union(Rect rect);
        public static bool operator ==(Rect rect1, Rect rect2);
        public static bool operator !=(Rect rect1, Rect rect2);
    }

    public sealed class RoutedEvent
    {
        public override string ToString();
    }

    public sealed class SecuritySettings: DependencyObject
    {
        public SecuritySettings();
        public static readonly DependencyProperty ElevatedPermissionsProperty;
        public ElevatedPermissions ElevatedPermissions { get; }
    }

    public sealed class Setter: SetterBase
    {
        public Setter();
        public Setter(DependencyProperty property, object value);
        public DependencyProperty Property { get; set; }
        public object Value { get; set; }
    }

    public abstract class SetterBase: DependencyObject
    {
        public bool IsSealed { get; }
    }

    public struct Size
    {
        public Size(double width, double height);
        public static Size Empty { get; }
        public double Height { get; set; }
        public bool IsEmpty { get; }
        public double Width { get; set; }
        public override bool Equals(object o);
        public bool Equals(Size value);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(Size size1, Size size2);
        public static bool operator !=(Size size1, Size size2);
    }

    [ContentPropertyAttribute(..)]
    public sealed class Style: DependencyObject
    {
        public Style();
        public Style(Type targetType);
        public Style BasedOn { get; set; }
        public bool IsSealed { get; }
        public SetterBaseCollection Setters { get; }
        public Type TargetType { get; set; }
        public void Seal();
    }

    public abstract sealed class SystemColors
    {
        public static Color ActiveBorderColor { get; }
        public static Color ActiveCaptionColor { get; }
        public static Color ActiveCaptionTextColor { get; }
        public static Color AppWorkspaceColor { get; }
        public static Color ControlColor { get; }
        public static Color ControlDarkColor { get; }
        public static Color ControlDarkDarkColor { get; }
        public static Color ControlLightColor { get; }
        public static Color ControlLightLightColor { get; }
        public static Color ControlTextColor { get; }
        public static Color DesktopColor { get; }
        public static Color GrayTextColor { get; }
        public static Color HighlightColor { get; }
        public static Color HighlightTextColor { get; }
        public static Color InactiveBorderColor { get; }
        public static Color InactiveCaptionColor { get; }
        public static Color InactiveCaptionTextColor { get; }
        public static Color InfoColor { get; }
        public static Color InfoTextColor { get; }
        public static Color MenuColor { get; }
        public static Color MenuTextColor { get; }
        public static Color ScrollBarColor { get; }
        public static Color WindowColor { get; }
        public static Color WindowFrameColor { get; }
        public static Color WindowTextColor { get; }
    }

    public abstract sealed class SystemParameters
    {
        public static bool HighContrast { get; }
        public static int WheelScrollLines { get; }
    }

    public class TemplateBindingExpression: Expression
    {
    }

    public sealed class TextDecorationCollection
    {
    }

    public abstract sealed class TextDecorations
    {
        public static TextDecorationCollection Underline { get; }
    }

    public struct Thickness
    {
        public Thickness(double uniformLength);
        public Thickness(double left, double top, double right, double bottom);
        public double Bottom { get; set; }
        public double Left { get; set; }
        public double Right { get; set; }
        public double Top { get; set; }
        public override bool Equals(object obj);
        public bool Equals(Thickness thickness);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(Thickness t1, Thickness t2);
        public static bool operator !=(Thickness t1, Thickness t2);
    }

    public abstract class TriggerAction: DependencyObject
    {
    }

    public abstract class TriggerBase: DependencyObject
    {
    }

    public abstract class UIElement: DependencyObject
    {
        public static readonly DependencyProperty AllowDropProperty;
        public static readonly DependencyProperty CacheModeProperty;
        public static readonly DependencyProperty ClipProperty;
        public static readonly DependencyProperty EffectProperty;
        public static readonly DependencyProperty IsHitTestVisibleProperty;
        public static readonly RoutedEvent KeyDownEvent;
        public static readonly RoutedEvent KeyUpEvent;
        public static readonly RoutedEvent MouseLeftButtonDownEvent;
        public static readonly RoutedEvent MouseLeftButtonUpEvent;
        public static readonly RoutedEvent MouseWheelEvent;
        public static readonly DependencyProperty OpacityMaskProperty;
        public static readonly DependencyProperty OpacityProperty;
        public static readonly DependencyProperty ProjectionProperty;
        public static readonly DependencyProperty RenderTransformOriginProperty;
        public static readonly DependencyProperty RenderTransformProperty;
        public static readonly RoutedEvent TextInputEvent;
        public static readonly RoutedEvent TextInputStartEvent;
        public static readonly RoutedEvent TextInputUpdateEvent;
        public static readonly DependencyProperty UseLayoutRoundingProperty;
        public static readonly DependencyProperty VisibilityProperty;
        public bool AllowDrop { get; set; }
        public CacheMode CacheMode { get; set; }
        public Geometry Clip { get; set; }
        public Size DesiredSize { get; }
        public Effect Effect { get; set; }
        public bool IsHitTestVisible { get; set; }
        public double Opacity { get; set; }
        public Brush OpacityMask { get; set; }
        public Projection Projection { get; set; }
        public Size RenderSize { get; }
        public Transform RenderTransform { get; set; }
        public Point RenderTransformOrigin { get; set; }
        public bool UseLayoutRounding { get; set; }
        public Visibility Visibility { get; set; }
        public void AddHandler(RoutedEvent routedEvent, Delegate handler, bool handledEventsToo);
        public void Arrange(Rect finalRect);
        public bool CaptureMouse();
        public void InvalidateArrange();
        public void InvalidateMeasure();
        public void Measure(Size availableSize);
        protected virtual AutomationPeer OnCreateAutomationPeer();
        public void ReleaseMouseCapture();
        public void RemoveHandler(RoutedEvent routedEvent, Delegate handler);
        public GeneralTransform TransformToVisual(UIElement visual);
        public void UpdateLayout();
        public event DragEventHandler DragEnter;
        public event DragEventHandler DragLeave;
        public event DragEventHandler DragOver;
        public event DragEventHandler Drop;
        public event RoutedEventHandler GotFocus;
        public event KeyEventHandler KeyDown;
        public event KeyEventHandler KeyUp;
        public event RoutedEventHandler LostFocus;
        public event MouseEventHandler LostMouseCapture;
        public event MouseEventHandler MouseEnter;
        public event MouseEventHandler MouseLeave;
        public event MouseButtonEventHandler MouseLeftButtonDown;
        public event MouseButtonEventHandler MouseLeftButtonUp;
        public event MouseEventHandler MouseMove;
        public event MouseButtonEventHandler MouseRightButtonDown;
        public event MouseButtonEventHandler MouseRightButtonUp;
        public event MouseWheelEventHandler MouseWheel;
        public event TextCompositionEventHandler TextInput;
        public event TextCompositionEventHandler TextInputStart;
        public event TextCompositionEventHandler TextInputUpdate;
    }

    [ContentPropertyAttribute(..)]
    public sealed class VisualState: DependencyObject
    {
        public VisualState();
        public string Name { get; }
        public Storyboard Storyboard { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class VisualStateGroup: DependencyObject
    {
        public VisualStateGroup();
        public VisualState CurrentState { get; }
        public string Name { get; }
        public IList States { get; }
        public IList Transitions { get; }
        public event EventHandler`1<VisualStateChangedEventArgs> CurrentStateChanged;
        public event EventHandler`1<VisualStateChangedEventArgs> CurrentStateChanging;
    }

    public class VisualStateManager: DependencyObject
    {
        public VisualStateManager();
        public static readonly DependencyProperty CustomVisualStateManagerProperty;
        public static VisualStateManager GetCustomVisualStateManager(FrameworkElement obj);
        public static IList GetVisualStateGroups(FrameworkElement obj);
        public static bool GoToState(Control control, string stateName, bool useTransitions);
        protected virtual bool GoToStateCore(Control control, FrameworkElement templateRoot, string stateName, VisualStateGroup group, VisualState state, bool useTransitions);
        protected void RaiseCurrentStateChanged(VisualStateGroup stateGroup, VisualState oldState, VisualState newState, Control control);
        protected void RaiseCurrentStateChanging(VisualStateGroup stateGroup, VisualState oldState, VisualState newState, Control control);
        public static void SetCustomVisualStateManager(FrameworkElement obj, VisualStateManager value);
    }

    [ContentPropertyAttribute(..)]
    public class VisualTransition: DependencyObject
    {
        public VisualTransition();
        public string From { get; set; }
        public Duration GeneratedDuration { get; set; }
        public IEasingFunction GeneratedEasingFunction { get; set; }
        public Storyboard Storyboard { get; set; }
        public string To { get; set; }
    }

    public sealed class Window: DependencyObject
    {
        public Window();
        public double Height { get; set; }
        public bool IsActive { get; }
        public double Left { get; set; }
        public double Top { get; set; }
        public bool TopMost { get; set; }
        public double Width { get; set; }
        public WindowState WindowState { get; set; }
        public bool Activate();
    }

    public sealed class WindowSettings: DependencyObject
    {
        public WindowSettings();
        public static readonly DependencyProperty HeightProperty;
        public static readonly DependencyProperty LeftProperty;
        public static readonly DependencyProperty TitleProperty;
        public static readonly DependencyProperty TopProperty;
        public static readonly DependencyProperty WidthProperty;
        public static readonly DependencyProperty WindowStartupLocationProperty;
        public double Height { get; }
        public double Left { get; }
        public string Title { get; }
        public double Top { get; }
        public double Width { get; }
        public WindowStartupLocation WindowStartupLocation { get; }
    }

    public enum CrossDomainAccess
    {
        NoAccess,
        ScriptableOnly,
    }

    public enum ElevatedPermissions
    {
        NotRequired,
        Required,
    }

    public enum FlowDirection
    {
        LeftToRight,
        RightToLeft,
    }

    public enum GridUnitType
    {
        Auto,
        Pixel,
        Star,
    }

    public enum HorizontalAlignment
    {
        Center,
        Left,
        Right,
        Stretch,
    }

    public enum InstallState
    {
        Installed,
        InstallFailed,
        Installing,
        NotInstalled,
    }

    public enum LineStackingStrategy
    {
        BlockLineHeight,
        MaxHeight,
    }

    public enum MessageBoxButton
    {
        OK,
        OKCancel,
    }

    public enum MessageBoxResult
    {
        Cancel,
        No,
        None,
        OK,
        Yes,
    }

    public enum TextAlignment
    {
        Center,
        Left,
        Right,
    }

    public enum TextTrimming
    {
        None,
        WordEllipsis,
    }

    public enum TextWrapping
    {
        NoWrap,
        Wrap,
    }

    public enum VerticalAlignment
    {
        Bottom,
        Center,
        Stretch,
        Top,
    }

    public enum Visibility
    {
        Collapsed,
        Visible,
    }

    public enum WindowStartupLocation
    {
        CenterScreen,
        Manual,
    }

    public enum WindowState
    {
        Maximized,
        Minimized,
        Normal,
    }

    [DefaultMemberAttribute(..)]
    public sealed class AssemblyPartCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public AssemblyPartCollection();
    }

    [DefaultMemberAttribute(..)]
    public class DependencyObjectCollection`1<T>: DependencyObject, IList, IList`1<T>, INotifyCollectionChanged
    {
        public DependencyObjectCollection`1();
        public int Count { get; }
        public bool IsReadOnly { get; }
        public T this[int index] { get; set; }
        public void Add(T item);
        public void Clear();
        public bool Contains(T item);
        public void CopyTo(T[] array, int arrayIndex);
        public IEnumerator`1<T> GetEnumerator();
        public int IndexOf(T item);
        public void Insert(int index, T item);
        public bool Remove(T item);
        public void RemoveAt(int index);
        public event NotifyCollectionChangedEventHandler CollectionChanged;
    }

    [DefaultMemberAttribute(..)]
    public sealed class ExternalPartCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public ExternalPartCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class IconCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public IconCollection();
    }

    [DefaultMemberAttribute(..)]
    public abstract class PresentationFrameworkCollection`1<T>: DependencyObject, IList, IList`1<T>
    {
        public static readonly DependencyProperty CountProperty;
        public int Count { get; }
        public bool IsFixedSize { get; }
        public bool IsReadOnly { get; }
        public bool IsSynchronized { get; }
        public object SyncRoot { get; }
        public T this[int index] { get; set; }
        public void Add(T value);
        public void Clear();
        public bool Contains(T value);
        public void CopyTo(Array array, int index);
        public void CopyTo(T[] array, int index);
        public IEnumerator`1<T> GetEnumerator();
        public int IndexOf(T value);
        public void Insert(int index, T value);
        public bool Remove(T value);
        public void RemoveAt(int index);
    }

    [DefaultMemberAttribute(..)]
    public class ResourceDictionary: DependencyObject, IDictionary, IDictionary`2
    {
        [SecurityCriticalAttribute(..)]
        public ResourceDictionary();
        public int Count { get; }
        public bool IsFixedSize { get; }
        public bool IsReadOnly { get; }
        public ICollection Keys { get; }
        public PresentationFrameworkCollection`1<ResourceDictionary> MergedDictionaries { get; }
        public Uri Source { get; set; }
        public ICollection Values { get; }
        public object this[object key] { get; set; }
        public void Add(object key, object value);
        public void Add(string key, object value);
        public void Clear();
        public bool Contains(object key);
        public void CopyTo(Array array, int index);
        public IDictionaryEnumerator GetEnumerator();
        public void Remove(object key);
        public void Remove(string key);
    }

    [DefaultMemberAttribute(..)]
    public sealed class SetterBaseCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public SetterBaseCollection();
        public bool IsSealed { get; }
    }

    [DefaultMemberAttribute(..)]
    public sealed class TriggerActionCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public TriggerActionCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class TriggerCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
    }

    public class ApplicationUnhandledExceptionEventArgs: EventArgs
    {
        public ApplicationUnhandledExceptionEventArgs(Exception ex, bool handled);
        public Exception ExceptionObject { get; set; }
        public bool Handled { get; set; }
    }

    public sealed class CheckAndDownloadUpdateCompletedEventArgs: EventArgs
    {
        public Exception Error { get; }
        public bool UpdateAvailable { get; }
    }

    public delegate void CheckAndDownloadUpdateCompletedEventHandler(object sender, CheckAndDownloadUpdateCompletedEventArgs e);

    public delegate void DependencyPropertyChangedEventHandler(object sender, DependencyPropertyChangedEventArgs e);

    public sealed class DragEventArgs: RoutedEventArgs
    {
        public IDataObject Data { get; }
        public bool Handled { get; set; }
        public Point GetPosition(UIElement relativeTo);
    }

    public delegate void DragEventHandler(object sender, DragEventArgs e);

    public sealed class ExceptionRoutedEventArgs: RoutedEventArgs
    {
        public Exception ErrorException { get; }
    }

    public delegate void ExceptionRoutedEventHandler(object sender, ExceptionRoutedEventArgs e);

    public delegate void PropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e);

    public class RoutedEventArgs: EventArgs
    {
        public RoutedEventArgs();
        public object OriginalSource { get; set; }
    }

    public delegate void RoutedEventHandler(object sender, RoutedEventArgs e);

    public class RoutedPropertyChangedEventArgs`1<T>: RoutedEventArgs
    {
        public RoutedPropertyChangedEventArgs`1(T oldValue, T newValue);
        public T NewValue { get; set; }
        public T OldValue { get; set; }
    }

    public delegate void RoutedPropertyChangedEventHandler`1<T>(object sender, RoutedPropertyChangedEventArgs`1<T> e);

    public sealed class SizeChangedEventArgs: RoutedEventArgs
    {
        public Size NewSize { get; }
        public Size PreviousSize { get; }
    }

    public delegate void SizeChangedEventHandler(object sender, SizeChangedEventArgs e);

    public sealed class StartupEventArgs: EventArgs
    {
        public IDictionary`2<string,string> InitParams { get; }
    }

    public delegate void StartupEventHandler(object sender, StartupEventArgs e);

    public sealed class VisualStateChangedEventArgs: EventArgs
    {
        public VisualStateChangedEventArgs();
        public Control Control { get; set; }
        public VisualState NewState { get; set; }
        public VisualState OldState { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class StyleTypedPropertyAttribute: Attribute, _Attribute
    {
        public StyleTypedPropertyAttribute();
        public string Property { get; set; }
        public Type StyleTargetType { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class TemplatePartAttribute: Attribute, _Attribute
    {
        public TemplatePartAttribute();
        public string Name { get; set; }
        public Type Type { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class TemplateVisualStateAttribute: Attribute, _Attribute
    {
        public TemplateVisualStateAttribute();
        public string GroupName { get; set; }
        public string Name { get; set; }
    }

    public class LayoutCycleException: Exception, _Exception, ISerializable
    {
    }

} 

namespace System.Windows.Automation
{
    public abstract sealed class AutomationElementIdentifiers
    {
        public static readonly AutomationProperty AcceleratorKeyProperty;
        public static readonly AutomationProperty AccessKeyProperty;
        public static readonly AutomationProperty AutomationIdProperty;
        public static readonly AutomationProperty BoundingRectangleProperty;
        public static readonly AutomationProperty ClassNameProperty;
        public static readonly AutomationProperty ClickablePointProperty;
        public static readonly AutomationProperty ControlTypeProperty;
        public static readonly AutomationProperty HasKeyboardFocusProperty;
        public static readonly AutomationProperty HelpTextProperty;
        public static readonly AutomationProperty IsContentElementProperty;
        public static readonly AutomationProperty IsControlElementProperty;
        public static readonly AutomationProperty IsEnabledProperty;
        public static readonly AutomationProperty IsKeyboardFocusableProperty;
        public static readonly AutomationProperty IsOffscreenProperty;
        public static readonly AutomationProperty IsPasswordProperty;
        public static readonly AutomationProperty IsRequiredForFormProperty;
        public static readonly AutomationProperty ItemStatusProperty;
        public static readonly AutomationProperty ItemTypeProperty;
        public static readonly AutomationProperty LabeledByProperty;
        public static readonly AutomationProperty LocalizedControlTypeProperty;
        public static readonly AutomationProperty NameProperty;
        public static readonly AutomationProperty OrientationProperty;
    }

    public abstract sealed class AutomationProperties
    {
        public static readonly DependencyProperty AcceleratorKeyProperty;
        public static readonly DependencyProperty AccessKeyProperty;
        public static readonly DependencyProperty AutomationIdProperty;
        public static readonly DependencyProperty HelpTextProperty;
        public static readonly DependencyProperty IsRequiredForFormProperty;
        public static readonly DependencyProperty ItemStatusProperty;
        public static readonly DependencyProperty ItemTypeProperty;
        public static readonly DependencyProperty LabeledByProperty;
        public static readonly DependencyProperty NameProperty;
        public static string GetAcceleratorKey(DependencyObject element);
        public static string GetAccessKey(DependencyObject element);
        public static string GetAutomationId(DependencyObject element);
        public static string GetHelpText(DependencyObject element);
        public static bool GetIsRequiredForForm(DependencyObject element);
        public static string GetItemStatus(DependencyObject element);
        public static string GetItemType(DependencyObject element);
        public static UIElement GetLabeledBy(DependencyObject element);
        public static string GetName(DependencyObject element);
        public static void SetAcceleratorKey(DependencyObject element, string value);
        public static void SetAccessKey(DependencyObject element, string value);
        public static void SetAutomationId(DependencyObject element, string value);
        public static void SetHelpText(DependencyObject element, string value);
        public static void SetIsRequiredForForm(DependencyObject element, bool value);
        public static void SetItemStatus(DependencyObject element, string value);
        public static void SetItemType(DependencyObject element, string value);
        public static void SetLabeledBy(DependencyObject element, UIElement value);
        public static void SetName(DependencyObject element, string value);
    }

    public class AutomationProperty
    {
    }

    public abstract sealed class DockPatternIdentifiers
    {
        public static readonly AutomationProperty DockPositionProperty;
    }

    public abstract sealed class ExpandCollapsePatternIdentifiers
    {
        public static readonly AutomationProperty ExpandCollapseStateProperty;
    }

    public abstract sealed class GridItemPatternIdentifiers
    {
        public static readonly AutomationProperty ColumnProperty;
        public static readonly AutomationProperty ColumnSpanProperty;
        public static readonly AutomationProperty ContainingGridProperty;
        public static readonly AutomationProperty RowProperty;
        public static readonly AutomationProperty RowSpanProperty;
    }

    public abstract sealed class GridPatternIdentifiers
    {
        public static readonly AutomationProperty ColumnCountProperty;
        public static readonly AutomationProperty RowCountProperty;
    }

    public abstract sealed class MultipleViewPatternIdentifiers
    {
        public static readonly AutomationProperty CurrentViewProperty;
        public static readonly AutomationProperty SupportedViewsProperty;
    }

    public abstract sealed class RangeValuePatternIdentifiers
    {
        public static readonly AutomationProperty IsReadOnlyProperty;
        public static readonly AutomationProperty LargeChangeProperty;
        public static readonly AutomationProperty MaximumProperty;
        public static readonly AutomationProperty MinimumProperty;
        public static readonly AutomationProperty SmallChangeProperty;
        public static readonly AutomationProperty ValueProperty;
    }

    public abstract sealed class ScrollPatternIdentifiers
    {
        public static readonly AutomationProperty HorizontallyScrollableProperty;
        public static readonly AutomationProperty HorizontalScrollPercentProperty;
        public static readonly AutomationProperty HorizontalViewSizeProperty;
        public const double NoScroll;
        public static readonly AutomationProperty VerticallyScrollableProperty;
        public static readonly AutomationProperty VerticalScrollPercentProperty;
        public static readonly AutomationProperty VerticalViewSizeProperty;
    }

    public abstract sealed class SelectionItemPatternIdentifiers
    {
        public static readonly AutomationProperty IsSelectedProperty;
        public static readonly AutomationProperty SelectionContainerProperty;
    }

    public abstract sealed class SelectionPatternIdentifiers
    {
        public static readonly AutomationProperty CanSelectMultipleProperty;
        public static readonly AutomationProperty IsSelectionRequiredProperty;
        public static readonly AutomationProperty SelectionProperty;
    }

    public abstract sealed class TableItemPatternIdentifiers
    {
        public static readonly AutomationProperty ColumnHeaderItemsProperty;
        public static readonly AutomationProperty RowHeaderItemsProperty;
    }

    public abstract sealed class TablePatternIdentifiers
    {
        public static readonly AutomationProperty ColumnHeadersProperty;
        public static readonly AutomationProperty RowHeadersProperty;
        public static readonly AutomationProperty RowOrColumnMajorProperty;
    }

    public abstract sealed class TogglePatternIdentifiers
    {
        public static readonly AutomationProperty ToggleStateProperty;
    }

    public abstract sealed class TransformPatternIdentifiers
    {
        public static readonly AutomationProperty CanMoveProperty;
        public static readonly AutomationProperty CanResizeProperty;
        public static readonly AutomationProperty CanRotateProperty;
    }

    public abstract sealed class ValuePatternIdentifiers
    {
        public static readonly AutomationProperty IsReadOnlyProperty;
        public static readonly AutomationProperty ValueProperty;
    }

    public abstract sealed class WindowPatternIdentifiers
    {
        public static readonly AutomationProperty CanMaximizeProperty;
        public static readonly AutomationProperty CanMinimizeProperty;
        public static readonly AutomationProperty IsModalProperty;
        public static readonly AutomationProperty IsTopmostProperty;
        public static readonly AutomationProperty WindowInteractionStateProperty;
        public static readonly AutomationProperty WindowVisualStateProperty;
    }

    public enum DockPosition
    {
        Bottom,
        Fill,
        Left,
        None,
        Right,
        Top,
    }

    public enum ExpandCollapseState
    {
        Collapsed,
        Expanded,
        LeafNode,
        PartiallyExpanded,
    }

    public enum RowOrColumnMajor
    {
        ColumnMajor,
        Indeterminate,
        RowMajor,
    }

    public enum ScrollAmount
    {
        LargeDecrement,
        LargeIncrement,
        NoAmount,
        SmallDecrement,
        SmallIncrement,
    }

    public enum ToggleState
    {
        Indeterminate,
        Off,
        On,
    }

    public enum WindowInteractionState
    {
        BlockedByModalWindow,
        Closing,
        NotResponding,
        ReadyForUserInteraction,
        Running,
    }

    public enum WindowVisualState
    {
        Maximized,
        Minimized,
        Normal,
    }

    public class ElementNotAvailableException: Exception, _Exception, ISerializable
    {
        public ElementNotAvailableException();
    }

    public class ElementNotEnabledException: Exception, _Exception, ISerializable
    {
        public ElementNotEnabledException();
    }

} 

namespace System.Windows.Automation.Peers
{
    public abstract class AutomationPeer: DependencyObject
    {
        protected AutomationPeer();
        public AutomationPeer EventsSource { get; set; }
        public string GetAcceleratorKey();
        protected abstract string GetAcceleratorKeyCore();
        public string GetAccessKey();
        protected abstract string GetAccessKeyCore();
        public AutomationControlType GetAutomationControlType();
        protected abstract AutomationControlType GetAutomationControlTypeCore();
        public string GetAutomationId();
        protected abstract string GetAutomationIdCore();
        public Rect GetBoundingRectangle();
        protected abstract Rect GetBoundingRectangleCore();
        public List`1<AutomationPeer> GetChildren();
        protected abstract List`1<AutomationPeer> GetChildrenCore();
        public string GetClassName();
        protected abstract string GetClassNameCore();
        public Point GetClickablePoint();
        protected abstract Point GetClickablePointCore();
        public string GetHelpText();
        protected abstract string GetHelpTextCore();
        public string GetItemStatus();
        protected abstract string GetItemStatusCore();
        public string GetItemType();
        protected abstract string GetItemTypeCore();
        public AutomationPeer GetLabeledBy();
        protected abstract AutomationPeer GetLabeledByCore();
        public string GetLocalizedControlType();
        protected abstract string GetLocalizedControlTypeCore();
        public string GetName();
        protected abstract string GetNameCore();
        public AutomationOrientation GetOrientation();
        protected abstract AutomationOrientation GetOrientationCore();
        public AutomationPeer GetParent();
        public abstract object GetPattern(PatternInterface patternInterface);
        public bool HasKeyboardFocus();
        protected abstract bool HasKeyboardFocusCore();
        public void InvalidatePeer();
        public bool IsContentElement();
        protected abstract bool IsContentElementCore();
        public bool IsControlElement();
        protected abstract bool IsControlElementCore();
        public bool IsEnabled();
        protected abstract bool IsEnabledCore();
        public bool IsKeyboardFocusable();
        protected abstract bool IsKeyboardFocusableCore();
        public bool IsOffscreen();
        protected abstract bool IsOffscreenCore();
        public bool IsPassword();
        protected abstract bool IsPasswordCore();
        public bool IsRequiredForForm();
        protected abstract bool IsRequiredForFormCore();
        public static bool ListenerExists(AutomationEvents eventId);
        protected AutomationPeer PeerFromProvider(IRawElementProviderSimple provider);
        protected IRawElementProviderSimple ProviderFromPeer(AutomationPeer peer);
        public void RaiseAutomationEvent(AutomationEvents eventId);
        public void RaisePropertyChangedEvent(AutomationProperty property, object oldValue, object newValue);
        public void SetFocus();
        protected abstract void SetFocusCore();
    }

    public class ButtonAutomationPeer: ButtonBaseAutomationPeer, IInvokeProvider
    {
        public ButtonAutomationPeer(Button owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public abstract class ButtonBaseAutomationPeer: FrameworkElementAutomationPeer
    {
        protected ButtonBaseAutomationPeer(ButtonBase owner);
        protected override string GetNameCore();
    }

    public class CheckBoxAutomationPeer: ToggleButtonAutomationPeer, IToggleProvider
    {
        public CheckBoxAutomationPeer(CheckBox owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
    }

    public class ComboBoxAutomationPeer: SelectorAutomationPeer, IExpandCollapseProvider, ISelectionProvider, IValueProvider
    {
        public ComboBoxAutomationPeer(ComboBox owner);
        protected override ItemAutomationPeer CreateItemAutomationPeer(object item);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface pattern);
    }

    public class FrameworkElementAutomationPeer: AutomationPeer
    {
        public FrameworkElementAutomationPeer(FrameworkElement owner);
        public UIElement Owner { get; }
        public static AutomationPeer CreatePeerForElement(UIElement element);
        public static AutomationPeer FromElement(UIElement element);
        protected override string GetAcceleratorKeyCore();
        protected override string GetAccessKeyCore();
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetAutomationIdCore();
        protected override Rect GetBoundingRectangleCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        protected override Point GetClickablePointCore();
        protected override string GetHelpTextCore();
        protected override string GetItemStatusCore();
        protected override string GetItemTypeCore();
        protected override AutomationPeer GetLabeledByCore();
        protected override string GetLocalizedControlTypeCore();
        protected override string GetNameCore();
        protected override AutomationOrientation GetOrientationCore();
        public override object GetPattern(PatternInterface patternInterface);
        protected override bool HasKeyboardFocusCore();
        protected override bool IsContentElementCore();
        protected override bool IsControlElementCore();
        protected override bool IsEnabledCore();
        protected override bool IsKeyboardFocusableCore();
        protected override bool IsOffscreenCore();
        protected override bool IsPasswordCore();
        protected override bool IsRequiredForFormCore();
        protected override void SetFocusCore();
    }

    public class HyperlinkButtonAutomationPeer: ButtonBaseAutomationPeer, IInvokeProvider
    {
        public HyperlinkButtonAutomationPeer(HyperlinkButton owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
        protected override bool IsControlElementCore();
    }

    public class ImageAutomationPeer: FrameworkElementAutomationPeer
    {
        public ImageAutomationPeer(Image owner);
    }

    public abstract class ItemAutomationPeer: FrameworkElementAutomationPeer
    {
        protected ItemAutomationPeer(object item, ItemsControlAutomationPeer itemsControlAutomationPeer);
        protected ItemAutomationPeer(UIElement item);
        protected object Item { get; }
        protected ItemsControlAutomationPeer ItemsControlAutomationPeer { get; }
        protected override string GetAcceleratorKeyCore();
        protected override string GetAccessKeyCore();
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetAutomationIdCore();
        protected override Rect GetBoundingRectangleCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        protected override Point GetClickablePointCore();
        protected override string GetHelpTextCore();
        protected override string GetItemStatusCore();
        protected override string GetItemTypeCore();
        protected override AutomationPeer GetLabeledByCore();
        protected override string GetLocalizedControlTypeCore();
        protected override string GetNameCore();
        protected override AutomationOrientation GetOrientationCore();
        public override object GetPattern(PatternInterface patternInterface);
        protected override bool HasKeyboardFocusCore();
        protected override bool IsContentElementCore();
        protected override bool IsControlElementCore();
        protected override bool IsEnabledCore();
        protected override bool IsKeyboardFocusableCore();
        protected override bool IsOffscreenCore();
        protected override bool IsPasswordCore();
        protected override bool IsRequiredForFormCore();
        protected override void SetFocusCore();
    }

    public abstract class ItemsControlAutomationPeer: FrameworkElementAutomationPeer
    {
        protected ItemsControlAutomationPeer(ItemsControl owner);
        protected virtual ItemAutomationPeer CreateItemAutomationPeer(object item);
        protected override List`1<AutomationPeer> GetChildrenCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class ListBoxAutomationPeer: SelectorAutomationPeer, ISelectionProvider
    {
        public ListBoxAutomationPeer(ListBox owner);
        protected override ItemAutomationPeer CreateItemAutomationPeer(object item);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
    }

    public class ListBoxItemAutomationPeer: SelectorItemAutomationPeer, IScrollItemProvider, ISelectionItemProvider
    {
        public ListBoxItemAutomationPeer(ListBoxItem owner);
        public ListBoxItemAutomationPeer(object owner, SelectorAutomationPeer selectorAutomationPeer);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class MediaElementAutomationPeer: FrameworkElementAutomationPeer
    {
        public MediaElementAutomationPeer(MediaElement owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
    }

    public class MultiScaleImageAutomationPeer: FrameworkElementAutomationPeer
    {
        public MultiScaleImageAutomationPeer(MultiScaleImage owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
    }

    public class PasswordBoxAutomationPeer: FrameworkElementAutomationPeer, IValueProvider
    {
        public PasswordBoxAutomationPeer(PasswordBox owner);
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class ProgressBarAutomationPeer: RangeBaseAutomationPeer, IRangeValueProvider
    {
        public ProgressBarAutomationPeer(ProgressBar owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class RadioButtonAutomationPeer: ToggleButtonAutomationPeer, ISelectionItemProvider, IToggleProvider
    {
        public RadioButtonAutomationPeer(RadioButton owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class RangeBaseAutomationPeer: FrameworkElementAutomationPeer, IRangeValueProvider
    {
        public RangeBaseAutomationPeer(RangeBase owner);
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class RepeatButtonAutomationPeer: ButtonBaseAutomationPeer, IInvokeProvider
    {
        public RepeatButtonAutomationPeer(RepeatButton owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class ScrollBarAutomationPeer: RangeBaseAutomationPeer, IRangeValueProvider
    {
        public ScrollBarAutomationPeer(ScrollBar owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override Point GetClickablePointCore();
        protected override AutomationOrientation GetOrientationCore();
    }

    public class ScrollViewerAutomationPeer: FrameworkElementAutomationPeer, IScrollProvider
    {
        public ScrollViewerAutomationPeer(ScrollViewer owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
        protected override bool IsControlElementCore();
    }

    public abstract class SelectorAutomationPeer: ItemsControlAutomationPeer, ISelectionProvider
    {
        protected SelectorAutomationPeer(Selector owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public abstract class SelectorItemAutomationPeer: ItemAutomationPeer, ISelectionItemProvider
    {
        protected SelectorItemAutomationPeer(object owner, SelectorAutomationPeer selectorAutomationPeer);
        protected SelectorItemAutomationPeer(UIElement owner);
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class SliderAutomationPeer: RangeBaseAutomationPeer, IRangeValueProvider
    {
        public SliderAutomationPeer(Slider owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override Point GetClickablePointCore();
    }

    public class TextBlockAutomationPeer: FrameworkElementAutomationPeer
    {
        public TextBlockAutomationPeer(TextBlock owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
        protected override bool IsControlElementCore();
    }

    public class TextBoxAutomationPeer: FrameworkElementAutomationPeer, IValueProvider
    {
        public TextBoxAutomationPeer(TextBox owner);
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class ThumbAutomationPeer: FrameworkElementAutomationPeer
    {
        public ThumbAutomationPeer(Thumb owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
    }

    public class ToggleButtonAutomationPeer: ButtonBaseAutomationPeer, IToggleProvider
    {
        public ToggleButtonAutomationPeer(ToggleButton owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public enum AutomationControlType
    {
        Button,
        Calendar,
        CheckBox,
        ComboBox,
        Custom,
        DataGrid,
        DataItem,
        Document,
        Edit,
        Group,
        Header,
        HeaderItem,
        Hyperlink,
        Image,
        List,
        ListItem,
        Menu,
        MenuBar,
        MenuItem,
        Pane,
        ProgressBar,
        RadioButton,
        ScrollBar,
        Separator,
        Slider,
        Spinner,
        SplitButton,
        StatusBar,
        Tab,
        TabItem,
        Table,
        Text,
        Thumb,
        TitleBar,
        ToolBar,
        ToolTip,
        Tree,
        TreeItem,
        Window,
    }

    public enum AutomationEvents
    {
        AsyncContentLoaded,
        AutomationFocusChanged,
        InvokePatternOnInvoked,
        MenuClosed,
        MenuOpened,
        PropertyChanged,
        SelectionItemPatternOnElementAddedToSelection,
        SelectionItemPatternOnElementRemovedFromSelection,
        SelectionItemPatternOnElementSelected,
        SelectionPatternOnInvalidated,
        StructureChanged,
        TextPatternOnTextChanged,
        TextPatternOnTextSelectionChanged,
        ToolTipClosed,
        ToolTipOpened,
    }

    public enum AutomationOrientation
    {
        Horizontal,
        None,
        Vertical,
    }

    public enum PatternInterface
    {
        Dock,
        ExpandCollapse,
        Grid,
        GridItem,
        Invoke,
        MultipleView,
        RangeValue,
        Scroll,
        ScrollItem,
        Selection,
        SelectionItem,
        Table,
        TableItem,
        Toggle,
        Transform,
        Value,
        Window,
    }

} 

namespace System.Windows.Automation.Provider
{
    public interface IDockProvider
    {
        public DockPosition DockPosition { get; }
        public void SetDockPosition(DockPosition dockPosition);
    }

    public interface IExpandCollapseProvider
    {
        public ExpandCollapseState ExpandCollapseState { get; }
        public void Collapse();
        public void Expand();
    }

    public interface IGridItemProvider
    {
        public int Column { get; }
        public int ColumnSpan { get; }
        public IRawElementProviderSimple ContainingGrid { get; }
        public int Row { get; }
        public int RowSpan { get; }
    }

    public interface IGridProvider
    {
        public int ColumnCount { get; }
        public int RowCount { get; }
        public IRawElementProviderSimple GetItem(int row, int column);
    }

    public interface IInvokeProvider
    {
        public void Invoke();
    }

    public interface IMultipleViewProvider
    {
        public int CurrentView { get; }
        public int[] GetSupportedViews();
        public string GetViewName(int viewId);
        public void SetCurrentView(int viewId);
    }

    public interface IRangeValueProvider
    {
        public bool IsReadOnly { get; }
        public double LargeChange { get; }
        public double Maximum { get; }
        public double Minimum { get; }
        public double SmallChange { get; }
        public double Value { get; }
        public void SetValue(double value);
    }

    public sealed class IRawElementProviderSimple
    {
    }

    public interface IScrollItemProvider
    {
        public void ScrollIntoView();
    }

    public interface IScrollProvider
    {
        public bool HorizontallyScrollable { get; }
        public double HorizontalScrollPercent { get; }
        public double HorizontalViewSize { get; }
        public bool VerticallyScrollable { get; }
        public double VerticalScrollPercent { get; }
        public double VerticalViewSize { get; }
        public void Scroll(ScrollAmount horizontalAmount, ScrollAmount verticalAmount);
        public void SetScrollPercent(double horizontalPercent, double verticalPercent);
    }

    public interface ISelectionItemProvider
    {
        public bool IsSelected { get; }
        public IRawElementProviderSimple SelectionContainer { get; }
        public void AddToSelection();
        public void RemoveFromSelection();
        public void Select();
    }

    public interface ISelectionProvider
    {
        public bool CanSelectMultiple { get; }
        public bool IsSelectionRequired { get; }
        public IRawElementProviderSimple[] GetSelection();
    }

    public interface ITableItemProvider: IGridItemProvider
    {
        public IRawElementProviderSimple[] GetColumnHeaderItems();
        public IRawElementProviderSimple[] GetRowHeaderItems();
    }

    public interface ITableProvider: IGridProvider
    {
        public RowOrColumnMajor RowOrColumnMajor { get; }
        public IRawElementProviderSimple[] GetColumnHeaders();
        public IRawElementProviderSimple[] GetRowHeaders();
    }

    public interface IToggleProvider
    {
        public ToggleState ToggleState { get; }
        public void Toggle();
    }

    public interface ITransformProvider
    {
        public bool CanMove { get; }
        public bool CanResize { get; }
        public bool CanRotate { get; }
        public void Move(double x, double y);
        public void Resize(double width, double height);
        public void Rotate(double degrees);
    }

    public interface IValueProvider
    {
        public bool IsReadOnly { get; }
        public string Value { get; }
        public void SetValue(string value);
    }

    public interface IWindowProvider
    {
        public WindowInteractionState InteractionState { get; }
        public bool IsModal { get; }
        public bool IsTopmost { get; }
        public bool Maximizable { get; }
        public bool Minimizable { get; }
        public WindowVisualState VisualState { get; }
        public void Close();
        public void SetVisualState(WindowVisualState state);
        public bool WaitForInputIdle(int milliseconds);
    }

} 

namespace System.Windows.Controls
{
    [ContentPropertyAttribute(..)]
    public sealed class Border: FrameworkElement
    {
        public Border();
        public static readonly DependencyProperty BackgroundProperty;
        public static readonly DependencyProperty BorderBrushProperty;
        public static readonly DependencyProperty BorderThicknessProperty;
        public static readonly DependencyProperty CornerRadiusProperty;
        public static readonly DependencyProperty PaddingProperty;
        public Brush Background { get; set; }
        public Brush BorderBrush { get; set; }
        public Thickness BorderThickness { get; set; }
        public UIElement Child { get; set; }
        public CornerRadius CornerRadius { get; set; }
        public Thickness Padding { get; set; }
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class Button: ButtonBase
    {
        public Button();
        public override void OnApplyTemplate();
        protected override void OnClick();
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [ContentPropertyAttribute(..)]
    public class Canvas: Panel
    {
        public Canvas();
        public static readonly DependencyProperty LeftProperty;
        public static readonly DependencyProperty TopProperty;
        public static readonly DependencyProperty ZIndexProperty;
        protected sealed override Size ArrangeOverride(Size arrangeSize);
        public static double GetLeft(UIElement element);
        public static double GetTop(UIElement element);
        public static int GetZIndex(UIElement element);
        protected sealed override Size MeasureOverride(Size constraint);
        public static void SetLeft(UIElement element, double length);
        public static void SetTop(UIElement element, double length);
        public static void SetZIndex(UIElement element, int value);
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class CheckBox: ToggleButton
    {
        public CheckBox();
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    public sealed class ColumnDefinition: DependencyObject
    {
        public ColumnDefinition();
        public static readonly DependencyProperty MaxWidthProperty;
        public static readonly DependencyProperty MinWidthProperty;
        public static readonly DependencyProperty WidthProperty;
        public double ActualWidth { get; }
        public double MaxWidth { get; set; }
        public double MinWidth { get; set; }
        public GridLength Width { get; set; }
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ComboBox: Selector
    {
        public ComboBox();
        public static readonly DependencyProperty IsDropDownOpenProperty;
        public static readonly DependencyProperty IsSelectionActiveProperty;
        public static readonly DependencyProperty ItemContainerStyleProperty;
        public static readonly DependencyProperty MaxDropDownHeightProperty;
        public bool IsDropDownOpen { get; set; }
        public bool IsEditable { get; }
        public bool IsSelectionBoxHighlighted { get; set; }
        public Style ItemContainerStyle { get; set; }
        public double MaxDropDownHeight { get; set; }
        public object SelectionBoxItem { get; set; }
        public DataTemplate SelectionBoxItemTemplate { get; set; }
        protected override Size ArrangeOverride(Size arrangeBounds);
        protected override void ClearContainerForItemOverride(DependencyObject element, object item);
        protected override DependencyObject GetContainerForItemOverride();
        protected override bool IsItemItsOwnContainerOverride(object item);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnDropDownClosed(EventArgs e);
        protected virtual void OnDropDownOpened(EventArgs e);
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseWheel(MouseWheelEventArgs e);
        protected override void PrepareContainerForItemOverride(DependencyObject element, object item);
        public event EventHandler DropDownClosed;
        public event EventHandler DropDownOpened;
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ComboBoxItem: ListBoxItem
    {
        public ComboBoxItem();
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
    }

    [ContentPropertyAttribute(..)]
    public class ContentControl: Control
    {
        [SecurityCriticalAttribute(..)]
        public ContentControl();
        public static readonly DependencyProperty ContentProperty;
        public static readonly DependencyProperty ContentTemplateProperty;
        public object Content { get; set; }
        public DataTemplate ContentTemplate { get; set; }
        protected virtual void OnContentChanged(object oldContent, object newContent);
    }

    [ContentPropertyAttribute(..)]
    public class ContentPresenter: FrameworkElement
    {
        public ContentPresenter();
        public static readonly DependencyProperty ContentProperty;
        public static readonly DependencyProperty ContentTemplateProperty;
        public object Content { get; set; }
        public DataTemplate ContentTemplate { get; set; }
    }

    public abstract class Control: FrameworkElement
    {
        [SecurityCriticalAttribute(..)]
        protected Control();
        public static readonly DependencyProperty BackgroundProperty;
        public static readonly DependencyProperty BorderBrushProperty;
        public static readonly DependencyProperty BorderThicknessProperty;
        protected static readonly DependencyProperty DefaultStyleKeyProperty;
        public static readonly DependencyProperty FontFamilyProperty;
        public static readonly DependencyProperty FontSizeProperty;
        public static readonly DependencyProperty FontStretchProperty;
        public static readonly DependencyProperty FontStyleProperty;
        public static readonly DependencyProperty FontWeightProperty;
        public static readonly DependencyProperty ForegroundProperty;
        public static readonly DependencyProperty HorizontalContentAlignmentProperty;
        public static readonly DependencyProperty IsEnabledProperty;
        public static readonly DependencyProperty IsTabStopProperty;
        public static readonly DependencyProperty PaddingProperty;
        public static readonly DependencyProperty TabIndexProperty;
        public static readonly DependencyProperty TabNavigationProperty;
        public static readonly DependencyProperty TemplateProperty;
        public static readonly DependencyProperty VerticalContentAlignmentProperty;
        public Brush Background { get; set; }
        public Brush BorderBrush { get; set; }
        public Thickness BorderThickness { get; set; }
        protected object DefaultStyleKey { get; set; }
        public FontFamily FontFamily { get; set; }
        public double FontSize { get; set; }
        public FontStretch FontStretch { get; set; }
        public FontStyle FontStyle { get; set; }
        public FontWeight FontWeight { get; set; }
        public Brush Foreground { get; set; }
        public HorizontalAlignment HorizontalContentAlignment { get; set; }
        public bool IsEnabled { get; set; }
        public bool IsTabStop { get; set; }
        public Thickness Padding { get; set; }
        public int TabIndex { get; set; }
        public KeyboardNavigationMode TabNavigation { get; set; }
        public ControlTemplate Template { get; set; }
        public VerticalAlignment VerticalContentAlignment { get; set; }
        public bool ApplyTemplate();
        public bool Focus();
        protected DependencyObject GetTemplateChild(string childName);
        protected virtual void OnDragEnter(DragEventArgs e);
        protected virtual void OnDragLeave(DragEventArgs e);
        protected virtual void OnDragOver(DragEventArgs e);
        protected virtual void OnDrop(DragEventArgs e);
        protected virtual void OnGotFocus(RoutedEventArgs e);
        protected virtual void OnKeyDown(KeyEventArgs e);
        protected virtual void OnKeyUp(KeyEventArgs e);
        protected virtual void OnLostFocus(RoutedEventArgs e);
        protected virtual void OnLostMouseCapture(MouseEventArgs e);
        protected virtual void OnMouseEnter(MouseEventArgs e);
        protected virtual void OnMouseLeave(MouseEventArgs e);
        protected virtual void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected virtual void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected virtual void OnMouseMove(MouseEventArgs e);
        protected virtual void OnMouseRightButtonDown(MouseButtonEventArgs e);
        protected virtual void OnMouseRightButtonUp(MouseButtonEventArgs e);
        protected virtual void OnMouseWheel(MouseWheelEventArgs e);
        protected virtual void OnTextInput(TextCompositionEventArgs e);
        protected virtual void OnTextInputStart(TextCompositionEventArgs e);
        protected virtual void OnTextInputUpdate(TextCompositionEventArgs e);
        public event DependencyPropertyChangedEventHandler IsEnabledChanged;
    }

    public sealed class ControlTemplate: FrameworkTemplate
    {
        public ControlTemplate();
        public Type TargetType { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public class Grid: Panel
    {
        public Grid();
        public static readonly DependencyProperty ColumnProperty;
        public static readonly DependencyProperty ColumnSpanProperty;
        public static readonly DependencyProperty RowProperty;
        public static readonly DependencyProperty RowSpanProperty;
        public static readonly DependencyProperty ShowGridLinesProperty;
        public ColumnDefinitionCollection ColumnDefinitions { get; }
        public RowDefinitionCollection RowDefinitions { get; }
        public bool ShowGridLines { get; set; }
        protected sealed override Size ArrangeOverride(Size arrangeSize);
        public static int GetColumn(FrameworkElement element);
        public static int GetColumnSpan(FrameworkElement element);
        public static int GetRow(FrameworkElement element);
        public static int GetRowSpan(FrameworkElement element);
        protected sealed override Size MeasureOverride(Size constraint);
        public static void SetColumn(FrameworkElement element, int value);
        public static void SetColumnSpan(FrameworkElement element, int value);
        public static void SetRow(FrameworkElement element, int value);
        public static void SetRowSpan(FrameworkElement element, int value);
    }

    public sealed class HtmlBrush: TileBrush
    {
        public HtmlBrush();
        public static readonly DependencyProperty SourceNameProperty;
        public string SourceName { get; set; }
        public void Redraw();
        public void SetSource(WebBrowser source);
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class HyperlinkButton: ButtonBase
    {
        public HyperlinkButton();
        public static readonly DependencyProperty NavigateUriProperty;
        public static readonly DependencyProperty TargetNameProperty;
        public Uri NavigateUri { get; set; }
        public string TargetName { get; set; }
        public override void OnApplyTemplate();
        protected override void OnClick();
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    public sealed class Image: FrameworkElement
    {
        public Image();
        public static readonly DependencyProperty SourceProperty;
        public static readonly DependencyProperty StretchProperty;
        public ImageSource Source { get; set; }
        public Stretch Stretch { get; set; }
        protected override AutomationPeer OnCreateAutomationPeer();
        public event EventHandler`1<ExceptionRoutedEventArgs> ImageFailed;
        public event EventHandler`1<RoutedEventArgs> ImageOpened;
    }

    public interface INavigate
    {
        public bool Navigate(Uri source);
    }

    [ContentPropertyAttribute(..)]
    public sealed class InkPresenter: Canvas
    {
        public InkPresenter();
        public static readonly DependencyProperty StrokesProperty;
        public StrokeCollection Strokes { get; set; }
    }

    public sealed class ItemContainerGenerator: IRecyclingItemContainerGenerator
    {
        public DependencyObject ContainerFromIndex(int index);
        public DependencyObject ContainerFromItem(object item);
        public GeneratorPosition GeneratorPositionFromIndex(int itemIndex);
        public int IndexFromContainer(DependencyObject container);
        public int IndexFromGeneratorPosition(GeneratorPosition position);
        public object ItemFromContainer(DependencyObject container);
        public event ItemsChangedEventHandler ItemsChanged;
    }

    [ContentPropertyAttribute(..)]
    public class ItemsControl: Control
    {
        public ItemsControl();
        public static readonly DependencyProperty DisplayMemberPathProperty;
        public static readonly DependencyProperty ItemsPanelProperty;
        public static readonly DependencyProperty ItemsSourceProperty;
        public static readonly DependencyProperty ItemTemplateProperty;
        public string DisplayMemberPath { get; set; }
        public ItemContainerGenerator ItemContainerGenerator { get; }
        public ItemCollection Items { get; }
        public ItemsPanelTemplate ItemsPanel { get; set; }
        public IEnumerable ItemsSource { get; set; }
        public DataTemplate ItemTemplate { get; set; }
        protected virtual void ClearContainerForItemOverride(DependencyObject element, object item);
        protected virtual DependencyObject GetContainerForItemOverride();
        public static ItemsControl GetItemsOwner(DependencyObject element);
        protected virtual bool IsItemItsOwnContainerOverride(object item);
        public static ItemsControl ItemsControlFromItemContainer(DependencyObject container);
        protected virtual void OnItemsChanged(NotifyCollectionChangedEventArgs e);
        protected virtual void PrepareContainerForItemOverride(DependencyObject element, object item);
    }

    public sealed class ItemsPanelTemplate: FrameworkTemplate
    {
        public ItemsPanelTemplate();
    }

    public sealed class ItemsPresenter: FrameworkElement
    {
        public ItemsPresenter();
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ListBox: Selector
    {
        public ListBox();
        public static readonly DependencyProperty IsSelectionActiveProperty;
        public static readonly DependencyProperty ItemContainerStyleProperty;
        public static readonly DependencyProperty SelectionModeProperty;
        public Style ItemContainerStyle { get; set; }
        public IList SelectedItems { get; }
        public SelectionMode SelectionMode { get; set; }
        protected override DependencyObject GetContainerForItemOverride();
        protected override bool IsItemItsOwnContainerOverride(object item);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        public void ScrollIntoView(object item);
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ListBoxItem: ContentControl
    {
        public ListBoxItem();
        public static readonly DependencyProperty IsSelectedProperty;
        public bool IsSelected { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
    }

    public sealed class MediaElement: FrameworkElement
    {
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        public MediaElement();
        public static readonly DependencyProperty AttributesProperty;
        public static readonly DependencyProperty AudioStreamCountProperty;
        public static readonly DependencyProperty AudioStreamIndexProperty;
        public static readonly DependencyProperty AutoPlayProperty;
        public static readonly DependencyProperty BalanceProperty;
        public static readonly DependencyProperty BufferingProgressProperty;
        public static readonly DependencyProperty BufferingTimeProperty;
        public static readonly DependencyProperty CanPauseProperty;
        public static readonly DependencyProperty CanSeekProperty;
        public static readonly DependencyProperty CurrentStateProperty;
        public static readonly DependencyProperty DownloadProgressOffsetProperty;
        public static readonly DependencyProperty DownloadProgressProperty;
        public static readonly DependencyProperty DroppedFramesPerSecondProperty;
        public static readonly DependencyProperty IsMutedProperty;
        public static readonly DependencyProperty NaturalDurationProperty;
        public static readonly DependencyProperty NaturalVideoHeightProperty;
        public static readonly DependencyProperty NaturalVideoWidthProperty;
        public static readonly DependencyProperty PositionProperty;
        public static readonly DependencyProperty RenderedFramesPerSecondProperty;
        public static readonly DependencyProperty SourceProperty;
        public static readonly DependencyProperty StretchProperty;
        public static readonly DependencyProperty VolumeProperty;
        public Dictionary`2<string,string> Attributes { get; }
        public int AudioStreamCount { get; }
        public Nullable`1<int> AudioStreamIndex { get; set; }
        public bool AutoPlay { get; set; }
        public double Balance { get; set; }
        public double BufferingProgress { get; }
        public TimeSpan BufferingTime { get; set; }
        public bool CanPause { get; }
        public bool CanSeek { get; }
        public MediaElementState CurrentState { get; }
        public double DownloadProgress { get; }
        public double DownloadProgressOffset { get; }
        public double DroppedFramesPerSecond { get; }
        public bool IsMuted { get; set; }
        public LicenseAcquirer LicenseAcquirer { get; set; }
        public TimelineMarkerCollection Markers { get; }
        public Duration NaturalDuration { get; }
        public int NaturalVideoHeight { get; }
        public int NaturalVideoWidth { get; }
        public TimeSpan Position { get; set; }
        public double RenderedFramesPerSecond { get; }
        public Uri Source { get; set; }
        public Stretch Stretch { get; set; }
        public double Volume { get; set; }
        protected override AutomationPeer OnCreateAutomationPeer();
        public void Pause();
        public void Play();
        public void RequestLog();
        public void SetSource(MediaStreamSource mediaStreamSource);
        public void SetSource(Stream stream);
        public void Stop();
        public event RoutedEventHandler BufferingProgressChanged;
        public event RoutedEventHandler CurrentStateChanged;
        public event RoutedEventHandler DownloadProgressChanged;
        public event LogReadyRoutedEventHandler LogReady;
        public event TimelineMarkerRoutedEventHandler MarkerReached;
        public event RoutedEventHandler MediaEnded;
        public event EventHandler`1<ExceptionRoutedEventArgs> MediaFailed;
        public event RoutedEventHandler MediaOpened;
    }

    public sealed class MultiScaleImage: FrameworkElement
    {
        public MultiScaleImage();
        public static readonly DependencyProperty AllowDownloadingProperty;
        public static readonly DependencyProperty AspectRatioProperty;
        public static readonly DependencyProperty BlurFactorProperty;
        public static readonly DependencyProperty IsDownloadingProperty;
        public static readonly DependencyProperty IsIdleProperty;
        public static readonly DependencyProperty SourceProperty;
        public static readonly DependencyProperty SubImagesProperty;
        public static readonly DependencyProperty UseSpringsProperty;
        public static readonly DependencyProperty ViewportOriginProperty;
        public static readonly DependencyProperty ViewportWidthProperty;
        public bool AllowDownloading { get; set; }
        public double AspectRatio { get; }
        public double BlurFactor { get; set; }
        public bool IsDownloading { get; }
        public bool IsIdle { get; }
        public MultiScaleTileSource Source { get; set; }
        public ReadOnlyCollection`1<MultiScaleSubImage> SubImages { get; }
        public bool UseSprings { get; set; }
        public Point ViewportOrigin { get; set; }
        public double ViewportWidth { get; set; }
        public Point ElementToLogicalPoint(Point elementPoint);
        public Point LogicalToElementPoint(Point logicalPoint);
        protected override AutomationPeer OnCreateAutomationPeer();
        public void ZoomAboutLogicalPoint(double zoomIncrementFactor, double zoomCenterLogicalX, double zoomCenterLogicalY);
        public event RoutedEventHandler ImageFailed;
        public event EventHandler`1<ExceptionRoutedEventArgs> ImageOpenFailed;
        public event RoutedEventHandler ImageOpenSucceeded;
        public event RoutedEventHandler MotionFinished;
        public event RoutedEventHandler ViewportChanged;
    }

    public sealed class MultiScaleSubImage: DependencyObject
    {
        public MultiScaleSubImage();
        public static readonly DependencyProperty AspectRatioProperty;
        public static readonly DependencyProperty OpacityProperty;
        public static readonly DependencyProperty ViewportOriginProperty;
        public static readonly DependencyProperty ViewportWidthProperty;
        public static readonly DependencyProperty ZIndexProperty;
        public double AspectRatio { get; }
        public double Opacity { get; set; }
        public Point ViewportOrigin { get; set; }
        public double ViewportWidth { get; set; }
        public int ZIndex { get; set; }
    }

    public sealed class OpenFileDialog
    {
        public OpenFileDialog();
        public FileInfo File { get; }
        public IEnumerable`1<FileInfo> Files { get; }
        public string Filter { get; set; }
        public int FilterIndex { get; set; }
        public bool Multiselect { get; set; }
        public Nullable`1<bool> ShowDialog();
    }

    [ContentPropertyAttribute(..)]
    public abstract class Panel: FrameworkElement
    {
        protected Panel();
        public static readonly DependencyProperty BackgroundProperty;
        public static readonly DependencyProperty IsItemsHostProperty;
        public Brush Background { get; set; }
        public UIElementCollection Children { get; }
        public bool IsItemsHost { get; }
    }

    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class PasswordBox: Control
    {
        public PasswordBox();
        public static readonly DependencyProperty CaretBrushProperty;
        public static readonly DependencyProperty MaxLengthProperty;
        public static readonly DependencyProperty PasswordCharProperty;
        public static readonly DependencyProperty PasswordProperty;
        public static readonly DependencyProperty SelectionBackgroundProperty;
        public static readonly DependencyProperty SelectionForegroundProperty;
        public double BaselineOffset { get; }
        public Brush CaretBrush { get; set; }
        public FontSource FontSource { get; set; }
        public int MaxLength { get; set; }
        public string Password { get; set; }
        public char PasswordChar { get; set; }
        public Brush SelectionBackground { get; set; }
        public Brush SelectionForeground { get; set; }
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnKeyUp(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected override void OnMouseMove(MouseEventArgs e);
        protected override void OnTextInput(TextCompositionEventArgs e);
        protected override void OnTextInputStart(TextCompositionEventArgs e);
        protected override void OnTextInputUpdate(TextCompositionEventArgs e);
        public void SelectAll();
        public event RoutedEventHandler PasswordChanged;
    }

    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ProgressBar: RangeBase
    {
        public ProgressBar();
        public static readonly DependencyProperty IsIndeterminateProperty;
        public bool IsIndeterminate { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnValueChanged(double oldValue, double newValue);
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class RadioButton: ToggleButton
    {
        public RadioButton();
        public static readonly DependencyProperty GroupNameProperty;
        public string GroupName { get; set; }
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnToggle();
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class RichTextArea: Control
    {
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        public RichTextArea();
        public static readonly DependencyProperty IsReadOnlyProperty;
        public static readonly DependencyProperty TextWrappingProperty;
        public double BaselineOffset { get; }
        public BlockCollection Blocks { get; }
        public ScrollBarVisibility HorizontalScrollBarVisibility { get; set; }
        public bool IsReadOnly { get; set; }
        public TextSelection Selection { get; }
        public TextWrapping TextWrapping { get; set; }
        public ScrollBarVisibility VerticalScrollBarVisibility { get; set; }
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnKeyUp(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected override void OnMouseMove(MouseEventArgs e);
        protected override void OnTextInput(TextCompositionEventArgs e);
        protected override void OnTextInputStart(TextCompositionEventArgs e);
        protected override void OnTextInputUpdate(TextCompositionEventArgs e);
        public event RoutedEventHandler SelectionChanged;
    }

    public sealed class RowDefinition: DependencyObject
    {
        public RowDefinition();
        public static readonly DependencyProperty HeightProperty;
        public static readonly DependencyProperty MaxHeightProperty;
        public static readonly DependencyProperty MinHeightProperty;
        public double ActualHeight { get; }
        public GridLength Height { get; set; }
        public double MaxHeight { get; set; }
        public double MinHeight { get; set; }
    }

    public sealed class SaveFileDialog
    {
        public SaveFileDialog();
        public string DefaultExt { get; set; }
        public string Filter { get; set; }
        public int FilterIndex { get; set; }
        public string SafeFileName { get; }
        public Stream OpenFile();
        public Nullable`1<bool> ShowDialog();
    }

    [ContentPropertyAttribute(..)]
    public sealed class ScrollContentPresenter: ContentPresenter, IScrollInfo
    {
        public ScrollContentPresenter();
        public bool CanHorizontallyScroll { get; set; }
        public bool CanVerticallyScroll { get; set; }
        public double ExtentHeight { get; }
        public double ExtentWidth { get; }
        public double HorizontalOffset { get; }
        public ScrollViewer ScrollOwner { get; set; }
        public double VerticalOffset { get; }
        public double ViewportHeight { get; }
        public double ViewportWidth { get; }
        protected override Size ArrangeOverride(Size arrangeSize);
        public void LineDown();
        public void LineLeft();
        public void LineRight();
        public void LineUp();
        public Rect MakeVisible(UIElement visual, Rect rectangle);
        protected override Size MeasureOverride(Size constraint);
        public void MouseWheelDown();
        public void MouseWheelLeft();
        public void MouseWheelRight();
        public void MouseWheelUp();
        public override void OnApplyTemplate();
        public void PageDown();
        public void PageLeft();
        public void PageRight();
        public void PageUp();
        public void SetHorizontalOffset(double offset);
        public void SetVerticalOffset(double offset);
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    public sealed class ScrollViewer: ContentControl
    {
        public ScrollViewer();
        public static readonly DependencyProperty ComputedHorizontalScrollBarVisibilityProperty;
        public static readonly DependencyProperty ComputedVerticalScrollBarVisibilityProperty;
        public static readonly DependencyProperty ExtentHeightProperty;
        public static readonly DependencyProperty ExtentWidthProperty;
        public static readonly DependencyProperty HorizontalOffsetProperty;
        public static readonly DependencyProperty HorizontalScrollBarVisibilityProperty;
        public static readonly DependencyProperty ScrollableHeightProperty;
        public static readonly DependencyProperty ScrollableWidthProperty;
        public static readonly DependencyProperty VerticalOffsetProperty;
        public static readonly DependencyProperty VerticalScrollBarVisibilityProperty;
        public static readonly DependencyProperty ViewportHeightProperty;
        public static readonly DependencyProperty ViewportWidthProperty;
        public Visibility ComputedHorizontalScrollBarVisibility { get; set; }
        public Visibility ComputedVerticalScrollBarVisibility { get; set; }
        public double ExtentHeight { get; set; }
        public double ExtentWidth { get; set; }
        public double HorizontalOffset { get; set; }
        public ScrollBarVisibility HorizontalScrollBarVisibility { get; set; }
        public double ScrollableHeight { get; set; }
        public double ScrollableWidth { get; set; }
        public double VerticalOffset { get; set; }
        public ScrollBarVisibility VerticalScrollBarVisibility { get; set; }
        public double ViewportHeight { get; set; }
        public double ViewportWidth { get; set; }
        public static ScrollBarVisibility GetHorizontalScrollBarVisibility(DependencyObject element);
        public static ScrollBarVisibility GetVerticalScrollBarVisibility(DependencyObject element);
        public void InvalidateScrollInfo();
        protected override Size MeasureOverride(Size constraint);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseWheel(MouseWheelEventArgs e);
        public void ScrollToHorizontalOffset(double offset);
        public void ScrollToVerticalOffset(double offset);
        public static void SetHorizontalScrollBarVisibility(DependencyObject element, ScrollBarVisibility horizontalScrollBarVisibility);
        public static void SetVerticalScrollBarVisibility(DependencyObject element, ScrollBarVisibility verticalScrollBarVisibility);
    }

    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class Slider: RangeBase
    {
        public Slider();
        public static readonly DependencyProperty IsDirectionReversedProperty;
        public static readonly DependencyProperty IsFocusedProperty;
        public static readonly DependencyProperty OrientationProperty;
        public bool IsDirectionReversed { get; set; }
        public bool IsFocused { get; set; }
        public Orientation Orientation { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnLostMouseCapture(MouseEventArgs e);
        protected override void OnMaximumChanged(double oldMaximum, double newMaximum);
        protected override void OnMinimumChanged(double oldMinimum, double newMinimum);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnValueChanged(double oldValue, double newValue);
    }

    [ContentPropertyAttribute(..)]
    public class StackPanel: Panel
    {
        public StackPanel();
        public static readonly DependencyProperty OrientationProperty;
        public Orientation Orientation { get; set; }
        protected sealed override Size ArrangeOverride(Size arrangeSize);
        protected sealed override Size MeasureOverride(Size constraint);
    }

    [ContentPropertyAttribute(..)]
    public sealed class TextBlock: FrameworkElement
    {
        public TextBlock();
        public static readonly DependencyProperty FontFamilyProperty;
        public static readonly DependencyProperty FontSizeProperty;
        public static readonly DependencyProperty FontStretchProperty;
        public static readonly DependencyProperty FontStyleProperty;
        public static readonly DependencyProperty FontWeightProperty;
        public static readonly DependencyProperty ForegroundProperty;
        public static readonly DependencyProperty LineHeightProperty;
        public static readonly DependencyProperty LineStackingStrategyProperty;
        public static readonly DependencyProperty PaddingProperty;
        public static readonly DependencyProperty TextAlignmentProperty;
        public static readonly DependencyProperty TextDecorationsProperty;
        public static readonly DependencyProperty TextProperty;
        public static readonly DependencyProperty TextTrimmingProperty;
        public static readonly DependencyProperty TextWrappingProperty;
        public double BaselineOffset { get; }
        public FontFamily FontFamily { get; set; }
        public double FontSize { get; set; }
        public FontSource FontSource { get; set; }
        public FontStretch FontStretch { get; set; }
        public FontStyle FontStyle { get; set; }
        public FontWeight FontWeight { get; set; }
        public Brush Foreground { get; set; }
        public InlineCollection Inlines { get; }
        public double LineHeight { get; set; }
        public LineStackingStrategy LineStackingStrategy { get; set; }
        public Thickness Padding { get; set; }
        public string Text { get; set; }
        public TextAlignment TextAlignment { get; set; }
        public TextDecorationCollection TextDecorations { get; set; }
        public TextTrimming TextTrimming { get; set; }
        public TextWrapping TextWrapping { get; set; }
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class TextBox: Control
    {
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        public TextBox();
        public static readonly DependencyProperty AcceptsReturnProperty;
        public static readonly DependencyProperty CaretBrushProperty;
        public static readonly DependencyProperty IsReadOnlyProperty;
        public static readonly DependencyProperty MaxLengthProperty;
        public static readonly DependencyProperty SelectionBackgroundProperty;
        public static readonly DependencyProperty SelectionForegroundProperty;
        public static readonly DependencyProperty TextAlignmentProperty;
        public static readonly DependencyProperty TextProperty;
        public static readonly DependencyProperty TextWrappingProperty;
        public bool AcceptsReturn { get; set; }
        public double BaselineOffset { get; }
        public Brush CaretBrush { get; set; }
        public FontSource FontSource { get; set; }
        public ScrollBarVisibility HorizontalScrollBarVisibility { get; set; }
        public bool IsReadOnly { get; set; }
        public int MaxLength { get; set; }
        public string SelectedText { get; set; }
        public Brush SelectionBackground { get; set; }
        public Brush SelectionForeground { get; set; }
        public int SelectionLength { get; set; }
        public int SelectionStart { get; set; }
        public string Text { get; set; }
        public TextAlignment TextAlignment { get; set; }
        public TextWrapping TextWrapping { get; set; }
        public ScrollBarVisibility VerticalScrollBarVisibility { get; set; }
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnKeyUp(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected override void OnMouseMove(MouseEventArgs e);
        protected override void OnMouseWheel(MouseWheelEventArgs e);
        protected override void OnTextInput(TextCompositionEventArgs e);
        protected override void OnTextInputStart(TextCompositionEventArgs e);
        protected override void OnTextInputUpdate(TextCompositionEventArgs e);
        public void Select(int start, int length);
        public void SelectAll();
        public event RoutedEventHandler SelectionChanged;
        public event TextChangedEventHandler TextChanged;
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ToolTip: ContentControl
    {
        public ToolTip();
        public static readonly DependencyProperty HorizontalOffsetProperty;
        public static readonly DependencyProperty IsOpenProperty;
        public static readonly DependencyProperty PlacementProperty;
        public static readonly DependencyProperty PlacementTargetProperty;
        public static readonly DependencyProperty VerticalOffsetProperty;
        public double HorizontalOffset { get; set; }
        public bool IsOpen { get; set; }
        public PlacementMode Placement { get; set; }
        public UIElement PlacementTarget { get; set; }
        public double VerticalOffset { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        public event RoutedEventHandler Closed;
        public event RoutedEventHandler Opened;
    }

    public abstract sealed class ToolTipService
    {
        public static readonly DependencyProperty PlacementProperty;
        public static readonly DependencyProperty PlacementTargetProperty;
        public static readonly DependencyProperty ToolTipProperty;
        public static PlacementMode GetPlacement(DependencyObject element);
        public static UIElement GetPlacementTarget(DependencyObject element);
        public static object GetToolTip(DependencyObject element);
        public static void SetPlacement(DependencyObject element, PlacementMode value);
        public static void SetPlacementTarget(DependencyObject element, UIElement value);
        public static void SetToolTip(DependencyObject element, object value);
    }

    [ContentPropertyAttribute(..)]
    public class UserControl: Control
    {
        public UserControl();
        protected static readonly DependencyProperty ContentProperty;
        protected UIElement Content { get; set; }
    }

    public abstract sealed class Validation
    {
        public static readonly DependencyProperty ErrorsProperty;
        public static readonly DependencyProperty HasErrorProperty;
        public static ReadOnlyObservableCollection`1<ValidationError> GetErrors(DependencyObject element);
        public static bool GetHasError(DependencyObject element);
    }

    public class ValidationError
    {
        public object ErrorContent { get; set; }
        public Exception Exception { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class Viewbox: FrameworkElement
    {
        public Viewbox();
        public static readonly DependencyProperty StretchDirectionProperty;
        public static readonly DependencyProperty StretchProperty;
        public UIElement Child { get; set; }
        public Stretch Stretch { get; set; }
        public StretchDirection StretchDirection { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public abstract class VirtualizingPanel: Panel
    {
        protected VirtualizingPanel();
        public IItemContainerGenerator ItemContainerGenerator { get; }
        protected void AddInternalChild(UIElement child);
        protected virtual void BringIndexIntoView(int index);
        protected void InsertInternalChild(int index, UIElement child);
        protected virtual void OnClearChildren();
        protected virtual void OnItemsChanged(object sender, ItemsChangedEventArgs args);
        protected void RemoveInternalChildRange(int index, int range);
    }

    [ContentPropertyAttribute(..)]
    public class VirtualizingStackPanel: VirtualizingPanel, IScrollInfo
    {
        public VirtualizingStackPanel();
        public static readonly DependencyProperty IsVirtualizingProperty;
        public static readonly DependencyProperty OrientationProperty;
        public static readonly DependencyProperty VirtualizationModeProperty;
        public bool CanHorizontallyScroll { get; set; }
        public bool CanVerticallyScroll { get; set; }
        public double ExtentHeight { get; }
        public double ExtentWidth { get; }
        public double HorizontalOffset { get; }
        public Orientation Orientation { get; set; }
        public ScrollViewer ScrollOwner { get; set; }
        public double VerticalOffset { get; }
        public double ViewportHeight { get; }
        public double ViewportWidth { get; }
        protected override Size ArrangeOverride(Size arrangeSize);
        public static bool GetIsVirtualizing(DependencyObject o);
        public static VirtualizationMode GetVirtualizationMode(DependencyObject element);
        public virtual void LineDown();
        public virtual void LineLeft();
        public virtual void LineRight();
        public virtual void LineUp();
        public Rect MakeVisible(UIElement visual, Rect rectangle);
        protected override Size MeasureOverride(Size constraint);
        public virtual void MouseWheelDown();
        public virtual void MouseWheelLeft();
        public virtual void MouseWheelRight();
        public virtual void MouseWheelUp();
        protected virtual void OnCleanUpVirtualizedItem(CleanUpVirtualizedItemEventArgs e);
        protected override void OnClearChildren();
        protected override void OnItemsChanged(object sender, ItemsChangedEventArgs args);
        public virtual void PageDown();
        public virtual void PageLeft();
        public virtual void PageRight();
        public virtual void PageUp();
        public void SetHorizontalOffset(double offset);
        public void SetVerticalOffset(double offset);
        public static void SetVirtualizationMode(DependencyObject element, VirtualizationMode value);
        public event CleanUpVirtualizedItemEventHandler CleanUpVirtualizedItemEvent;
    }

    public sealed class WebBrowser: FrameworkElement
    {
        public WebBrowser();
        public Uri Source { get; set; }
        public object InvokeScript(string scriptName);
        public object InvokeScript(string scriptName, params string[] args);
        public void Navigate(Uri source);
        public void NavigateToString(string text);
        public string SaveToString();
        public event EventHandler LoadCompleted;
        public event NotifyEventHandler ScriptNotify;
    }

    public enum ClickMode
    {
        Hover,
        Press,
        Release,
    }

    public enum Orientation
    {
        Horizontal,
        Vertical,
    }

    public enum ScrollBarVisibility
    {
        Auto,
        Disabled,
        Hidden,
        Visible,
    }

    public enum SelectionMode
    {
        Extended,
        Multiple,
        Single,
    }

    public enum StretchDirection
    {
        Both,
        DownOnly,
        UpOnly,
    }

    public enum ValidationErrorEventAction
    {
        Added,
        Removed,
    }

    public enum VirtualizationMode
    {
        Recycling,
        Standard,
    }

    [DefaultMemberAttribute(..)]
    public sealed class ColumnDefinitionCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
    }

    [DefaultMemberAttribute(..)]
    public sealed class ItemCollection: PresentationFrameworkCollection`1, IList, IList`1, INotifyCollectionChanged
    {
    }

    [DefaultMemberAttribute(..)]
    public sealed class RowDefinitionCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
    }

    [DefaultMemberAttribute(..)]
    public sealed class UIElementCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
    }

    public class CleanUpVirtualizedItemEventArgs: RoutedEventArgs
    {
        public bool Cancel { get; set; }
        public UIElement UIElement { get; }
        public object Value { get; }
    }

    public delegate void CleanUpVirtualizedItemEventHandler(object sender, CleanUpVirtualizedItemEventArgs e);

    public sealed class NotifyEventArgs: EventArgs
    {
        public string Value { get; }
    }

    public delegate void NotifyEventHandler(object sender, NotifyEventArgs e);

    public class SelectionChangedEventArgs: RoutedEventArgs
    {
        public SelectionChangedEventArgs(IList removedItems, IList addedItems);
        public IList AddedItems { get; }
        public IList RemovedItems { get; }
    }

    public delegate void SelectionChangedEventHandler(object sender, SelectionChangedEventArgs e);

    public sealed class TextChangedEventArgs: RoutedEventArgs
    {
    }

    public delegate void TextChangedEventHandler(object sender, TextChangedEventArgs e);

    public class ValidationErrorEventArgs: RoutedEventArgs
    {
        public ValidationErrorEventAction Action { get; set; }
        public ValidationError Error { get; set; }
        public bool Handled { get; set; }
    }

} 

namespace System.Windows.Controls.Primitives
{
    [ContentPropertyAttribute(..)]
    public abstract class ButtonBase: ContentControl
    {
        protected ButtonBase();
        public static readonly DependencyProperty ClickModeProperty;
        public static readonly DependencyProperty CommandParameterProperty;
        public static readonly DependencyProperty CommandProperty;
        public static readonly DependencyProperty IsFocusedProperty;
        public static readonly DependencyProperty IsMouseOverProperty;
        public static readonly DependencyProperty IsPressedProperty;
        public ClickMode ClickMode { get; set; }
        public ICommand Command { get; set; }
        public object CommandParameter { get; set; }
        public bool IsFocused { get; set; }
        public bool IsMouseOver { get; set; }
        public bool IsPressed { get; set; }
        protected virtual void OnClick();
        protected override void OnGotFocus(RoutedEventArgs e);
        protected virtual void OnIsPressedChanged(DependencyPropertyChangedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnKeyUp(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnLostMouseCapture(MouseEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected override void OnMouseMove(MouseEventArgs e);
        public event RoutedEventHandler Click;
    }

    public struct GeneratorPosition
    {
        public GeneratorPosition(int index, int offset);
        public int Index { get; set; }
        public int Offset { get; set; }
        public override bool Equals(object o);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(GeneratorPosition gp1, GeneratorPosition gp2);
        public static bool operator !=(GeneratorPosition gp1, GeneratorPosition gp2);
    }

    public interface IItemContainerGenerator
    {
        public DependencyObject GenerateNext(ref bool isNewlyRealized);
        public GeneratorPosition GeneratorPositionFromIndex(int itemIndex);
        public ItemContainerGenerator GetItemContainerGeneratorForPanel(Panel panel);
        public int IndexFromGeneratorPosition(GeneratorPosition position);
        public void PrepareItemContainer(DependencyObject container);
        public void Remove(GeneratorPosition position, int count);
        public void RemoveAll();
        public IDisposable StartAt(GeneratorPosition position, GeneratorDirection direction, bool allowStartAtRealizedItem);
    }

    public interface IRecyclingItemContainerGenerator: IItemContainerGenerator
    {
        public void Recycle(GeneratorPosition position, int count);
    }

    public interface IScrollInfo
    {
        public bool CanHorizontallyScroll { get; set; }
        public bool CanVerticallyScroll { get; set; }
        public double ExtentHeight { get; }
        public double ExtentWidth { get; }
        public double HorizontalOffset { get; }
        public ScrollViewer ScrollOwner { get; set; }
        public double VerticalOffset { get; }
        public double ViewportHeight { get; }
        public double ViewportWidth { get; }
        public void LineDown();
        public void LineLeft();
        public void LineRight();
        public void LineUp();
        public Rect MakeVisible(UIElement visual, Rect rectangle);
        public void MouseWheelDown();
        public void MouseWheelLeft();
        public void MouseWheelRight();
        public void MouseWheelUp();
        public void PageDown();
        public void PageLeft();
        public void PageRight();
        public void PageUp();
        public void SetHorizontalOffset(double offset);
        public void SetVerticalOffset(double offset);
    }

    public abstract sealed class LayoutInformation
    {
        public static Geometry GetLayoutClip(FrameworkElement element);
        public static UIElement GetLayoutExceptionElement(Dispatcher dispatcher);
        public static Rect GetLayoutSlot(FrameworkElement element);
    }

    [ContentPropertyAttribute(..)]
    public sealed class Popup: FrameworkElement
    {
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        public Popup();
        public static readonly DependencyProperty ChildProperty;
        public static readonly DependencyProperty HorizontalOffsetProperty;
        public static readonly DependencyProperty IsOpenProperty;
        public static readonly DependencyProperty VerticalOffsetProperty;
        public UIElement Child { get; set; }
        public double HorizontalOffset { get; set; }
        public bool IsOpen { get; set; }
        public double VerticalOffset { get; set; }
        protected override AutomationPeer OnCreateAutomationPeer();
        public event EventHandler Closed;
        public event EventHandler Opened;
    }

    public abstract class RangeBase: Control
    {
        protected RangeBase();
        public static readonly DependencyProperty LargeChangeProperty;
        public static readonly DependencyProperty MaximumProperty;
        public static readonly DependencyProperty MinimumProperty;
        public static readonly DependencyProperty SmallChangeProperty;
        public static readonly DependencyProperty ValueProperty;
        public double LargeChange { get; set; }
        public double Maximum { get; set; }
        public double Minimum { get; set; }
        public double SmallChange { get; set; }
        public double Value { get; set; }
        protected virtual void OnMaximumChanged(double oldMaximum, double newMaximum);
        protected virtual void OnMinimumChanged(double oldMinimum, double newMinimum);
        protected virtual void OnValueChanged(double oldValue, double newValue);
        public override string ToString();
        public event RoutedPropertyChangedEventHandler`1<double> ValueChanged;
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class RepeatButton: ButtonBase
    {
        public RepeatButton();
        public static readonly DependencyProperty DelayProperty;
        public static readonly DependencyProperty IntervalProperty;
        public int Delay { get; set; }
        public int Interval { get; set; }
        public override void OnApplyTemplate();
        protected override void OnClick();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnKeyUp(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected override void OnMouseMove(MouseEventArgs e);
    }

    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class ScrollBar: RangeBase
    {
        public ScrollBar();
        public static readonly DependencyProperty OrientationProperty;
        public static readonly DependencyProperty ViewportSizeProperty;
        public Orientation Orientation { get; set; }
        public double ViewportSize { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnLostMouseCapture(MouseEventArgs e);
        protected override void OnMaximumChanged(double oldMaximum, double newMaximum);
        protected override void OnMinimumChanged(double oldMinimum, double newMinimum);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected override void OnValueChanged(double oldValue, double newValue);
        public event ScrollEventHandler Scroll;
    }

    [ContentPropertyAttribute(..)]
    public abstract class Selector: ItemsControl
    {
        public static readonly DependencyProperty IsSynchronizedWithCurrentItemProperty;
        public static readonly DependencyProperty SelectedIndexProperty;
        public static readonly DependencyProperty SelectedItemProperty;
        public static readonly DependencyProperty SelectedValuePathProperty;
        public static readonly DependencyProperty SelectedValueProperty;
        public Nullable`1<bool> IsSynchronizedWithCurrentItem { get; set; }
        public int SelectedIndex { get; set; }
        public object SelectedItem { get; set; }
        public object SelectedValue { get; set; }
        public string SelectedValuePath { get; set; }
        protected override void ClearContainerForItemOverride(DependencyObject element, object item);
        public static bool GetIsSelectionActive(DependencyObject element);
        public override void OnApplyTemplate();
        protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e);
        protected override void PrepareContainerForItemOverride(DependencyObject element, object item);
        public event SelectionChangedEventHandler SelectionChanged;
    }

    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class Thumb: Control
    {
        public Thumb();
        public static readonly DependencyProperty IsDraggingProperty;
        public static readonly DependencyProperty IsFocusedProperty;
        public bool IsDragging { get; set; }
        public bool IsFocused { get; set; }
        public void CancelDrag();
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnLostMouseCapture(MouseEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseMove(MouseEventArgs e);
        public event DragCompletedEventHandler DragCompleted;
        public event DragDeltaEventHandler DragDelta;
        public event DragStartedEventHandler DragStarted;
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ToggleButton: ButtonBase
    {
        public ToggleButton();
        public static readonly DependencyProperty IsCheckedProperty;
        public static readonly DependencyProperty IsThreeStateProperty;
        public Nullable`1<bool> IsChecked { get; set; }
        public bool IsThreeState { get; set; }
        public override void OnApplyTemplate();
        protected override void OnClick();
        protected override void OnContentChanged(object oldContent, object newContent);
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnToggle();
        public override string ToString();
        public event RoutedEventHandler Checked;
        public event RoutedEventHandler Indeterminate;
        public event RoutedEventHandler Unchecked;
    }

    public enum GeneratorDirection
    {
        Backward,
        Forward,
    }

    public enum PlacementMode
    {
        Bottom,
        Left,
        Mouse,
        Right,
        Top,
    }

    public enum ScrollEventType
    {
        EndScroll,
        First,
        LargeDecrement,
        LargeIncrement,
        Last,
        SmallDecrement,
        SmallIncrement,
        ThumbPosition,
        ThumbTrack,
    }

    public class DragCompletedEventArgs: RoutedEventArgs
    {
        public DragCompletedEventArgs(double horizontalChange, double verticalChange, bool canceled);
        public bool Canceled { get; set; }
        public double HorizontalChange { get; set; }
        public double VerticalChange { get; set; }
    }

    public delegate void DragCompletedEventHandler(object sender, DragCompletedEventArgs e);

    public class DragDeltaEventArgs: RoutedEventArgs
    {
        public DragDeltaEventArgs(double horizontalChange, double verticalChange);
        public double HorizontalChange { get; set; }
        public double VerticalChange { get; set; }
    }

    public delegate void DragDeltaEventHandler(object sender, DragDeltaEventArgs e);

    public class DragStartedEventArgs: RoutedEventArgs
    {
        public DragStartedEventArgs(double horizontalOffset, double verticalOffset);
        public double HorizontalOffset { get; set; }
        public double VerticalOffset { get; set; }
    }

    public delegate void DragStartedEventHandler(object sender, DragStartedEventArgs e);

    public class ItemsChangedEventArgs: EventArgs
    {
        public NotifyCollectionChangedAction Action { get; }
        public int ItemCount { get; }
        public int ItemUICount { get; }
        public GeneratorPosition OldPosition { get; }
        public GeneratorPosition Position { get; }
    }

    public delegate void ItemsChangedEventHandler(object sender, ItemsChangedEventArgs e);

    public sealed class ScrollEventArgs: RoutedEventArgs
    {
        public ScrollEventArgs(ScrollEventType scrollEventType, double newValue);
        public double NewValue { get; }
        public ScrollEventType ScrollEventType { get; }
    }

    public delegate void ScrollEventHandler(object sender, ScrollEventArgs e);

} 

namespace System.Windows.Data
{
    public class Binding: BindingBase
    {
        public Binding();
        public Binding(string path);
        public bool BindsDirectlyToSource { get; set; }
        public IValueConverter Converter { get; set; }
        public CultureInfo ConverterCulture { get; set; }
        public object ConverterParameter { get; set; }
        public string ElementName { get; set; }
        public BindingMode Mode { get; set; }
        public bool NotifyOnValidationError { get; set; }
        public PropertyPath Path { get; set; }
        public RelativeSource RelativeSource { get; set; }
        public object Source { get; set; }
        public UpdateSourceTrigger UpdateSourceTrigger { get; set; }
        public bool ValidatesOnDataErrors { get; set; }
        public bool ValidatesOnExceptions { get; set; }
        public bool ValidatesOnNotifyDataErrors { get; set; }
    }

    public abstract class BindingBase
    {
        protected BindingBase();
        public object FallbackValue { get; set; }
        public string StringFormat { get; set; }
        public object TargetNullValue { get; set; }
        protected void CheckSealed();
    }

    public sealed class BindingExpression: BindingExpressionBase
    {
        public object DataItem { get; }
        public Binding ParentBinding { get; }
        public void UpdateSource();
    }

    public abstract class BindingExpressionBase: Expression
    {
    }

    public abstract sealed class BindingOperations
    {
        public static BindingExpressionBase SetBinding(DependencyObject target, DependencyProperty dp, BindingBase binding);
    }

    public abstract class CollectionViewGroup: INotifyPropertyChanged
    {
        protected CollectionViewGroup(object name);
        public abstract bool IsBottomLevel { get; }
        public int ItemCount { get; }
        public ReadOnlyObservableCollection`1<object> Items { get; }
        public object Name { get; }
        protected int ProtectedItemCount { get; set; }
        protected ObservableCollection`1<object> ProtectedItems { get; }
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e);
    }

    public class CollectionViewSource: DependencyObject
    {
        public CollectionViewSource();
        public static readonly DependencyProperty SourceProperty;
        public static readonly DependencyProperty ViewProperty;
        public CultureInfo Culture { get; set; }
        public ObservableCollection`1<GroupDescription> GroupDescriptions { get; }
        public SortDescriptionCollection SortDescriptions { get; }
        public object Source { get; set; }
        public ICollectionView View { get; }
        public IDisposable DeferRefresh();
        protected virtual void OnCollectionViewTypeChanged(Type oldCollectionViewType, Type newCollectionViewType);
        protected virtual void OnSourceChanged(object oldSource, object newSource);
        public event FilterEventHandler Filter;
    }

    public interface IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture);
        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture);
    }

    public class PropertyGroupDescription: GroupDescription, INotifyPropertyChanged
    {
        public PropertyGroupDescription();
        public PropertyGroupDescription(string propertyName);
        public PropertyGroupDescription(string propertyName, IValueConverter converter);
        public PropertyGroupDescription(string propertyName, IValueConverter converter, StringComparison stringComparison);
        public IValueConverter Converter { get; set; }
        public string PropertyName { get; set; }
        public StringComparison StringComparison { get; set; }
        public override object GroupNameFromItem(object item, int level, CultureInfo culture);
        public override bool NamesMatch(object groupName, object itemName);
    }

    public class RelativeSource
    {
        public RelativeSource();
        public RelativeSource(RelativeSourceMode mode);
        public RelativeSourceMode Mode { get; set; }
    }

    public enum BindingMode
    {
        OneTime,
        OneWay,
        TwoWay,
    }

    public enum RelativeSourceMode
    {
        Self,
        TemplatedParent,
    }

    public enum UpdateSourceTrigger
    {
        Default,
        Explicit,
    }

    public class FilterEventArgs: EventArgs
    {
        public bool Accepted { get; set; }
        public object Item { get; }
    }

    public delegate void FilterEventHandler(object sender, FilterEventArgs e);

} 

namespace System.Windows.Documents
{
    public abstract class Block: TextElement
    {
        protected Block();
        public static readonly DependencyProperty TextAlignmentProperty;
        public TextAlignment TextAlignment { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class Bold: Span
    {
        public Bold();
    }

    public class FontSource
    {
        public FontSource(Stream stream);
    }

    public sealed class Glyphs: FrameworkElement
    {
        public Glyphs();
        public static readonly DependencyProperty FillProperty;
        public static readonly DependencyProperty FontRenderingEmSizeProperty;
        public static readonly DependencyProperty FontUriProperty;
        public static readonly DependencyProperty IndicesProperty;
        public static readonly DependencyProperty OriginXProperty;
        public static readonly DependencyProperty OriginYProperty;
        public static readonly DependencyProperty StyleSimulationsProperty;
        public static readonly DependencyProperty UnicodeStringProperty;
        public Brush Fill { get; set; }
        public double FontRenderingEmSize { get; set; }
        public Uri FontUri { get; set; }
        public string Indices { get; set; }
        public double OriginX { get; set; }
        public double OriginY { get; set; }
        public StyleSimulations StyleSimulations { get; set; }
        public string UnicodeString { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class Hyperlink: Span
    {
        public Hyperlink();
        public static readonly DependencyProperty CommandParameterProperty;
        public static readonly DependencyProperty CommandProperty;
        public static readonly DependencyProperty MouseOverForegroundProperty;
        public static readonly DependencyProperty MouseOverTextDecorationsProperty;
        public static readonly DependencyProperty NavigateUriProperty;
        public static readonly DependencyProperty TargetNameProperty;
        public ICommand Command { get; set; }
        public object CommandParameter { get; set; }
        public Brush MouseOverForeground { get; set; }
        public TextDecorationCollection MouseOverTextDecorations { get; set; }
        public Uri NavigateUri { get; set; }
        public string TargetName { get; set; }
    }

    public abstract class Inline: TextElement
    {
        protected Inline();
        public static readonly DependencyProperty FontFamilyProperty;
        public static readonly DependencyProperty FontSizeProperty;
        public static readonly DependencyProperty FontStretchProperty;
        public static readonly DependencyProperty FontStyleProperty;
        public static readonly DependencyProperty FontWeightProperty;
        public static readonly DependencyProperty ForegroundProperty;
        public static readonly DependencyProperty LanguageProperty;
        public static readonly DependencyProperty TextDecorationsProperty;
    }

    [ContentPropertyAttribute(..)]
    public sealed class InlineUIContainer: Inline
    {
        public InlineUIContainer();
        public UIElement Child { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class Italic: Span
    {
        public Italic();
    }

    public sealed class LineBreak: Inline
    {
        public LineBreak();
    }

    [ContentPropertyAttribute(..)]
    public sealed class Paragraph: Block
    {
        public Paragraph();
        public InlineCollection Inlines { get; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class Run: Inline
    {
        public Run();
        public string Text { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public class Span: Inline
    {
        public Span();
        public InlineCollection Inlines { get; }
    }

    public abstract class TextElement: DependencyObject
    {
        protected TextElement();
        public static readonly DependencyProperty FontFamilyProperty;
        public static readonly DependencyProperty FontSizeProperty;
        public static readonly DependencyProperty FontStretchProperty;
        public static readonly DependencyProperty FontStyleProperty;
        public static readonly DependencyProperty FontWeightProperty;
        public static readonly DependencyProperty ForegroundProperty;
        public static readonly DependencyProperty LanguageProperty;
        public static readonly DependencyProperty TextDecorationsProperty;
        public FontFamily FontFamily { get; set; }
        public double FontSize { get; set; }
        public FontStretch FontStretch { get; set; }
        public FontStyle FontStyle { get; set; }
        public FontWeight FontWeight { get; set; }
        public Brush Foreground { get; set; }
        public XmlLanguage Language { get; set; }
        public string Name { get; }
        public TextDecorationCollection TextDecorations { get; set; }
        public object FindName(string name);
    }

    public sealed class TextSelection
    {
        public string Text { get; set; }
        public bool CanInsert(TextElement element);
        public object GetPropertyValue(DependencyProperty formattingProperty);
        public void Insert(TextElement element);
        public void SetPropertyValue(DependencyProperty formattingProperty, object value);
    }

    [ContentPropertyAttribute(..)]
    public sealed class Underline: Span
    {
        public Underline();
    }

    [DefaultMemberAttribute(..)]
    public sealed class BlockCollection: TextElementCollection`1, IList, IList`1
    {
    }

    [DefaultMemberAttribute(..)]
    public sealed class InlineCollection: TextElementCollection`1, IList, IList`1
    {
        public void Add(string text);
    }

    [DefaultMemberAttribute(..)]
    public abstract class TextElementCollection`1<T>: PresentationFrameworkCollection`1, IList, IList`1<T> where T:TextElement,INativeCoreTypeWrapper,IManagedPeer
    {
    }

} 

namespace System.Windows.Ink
{
    public sealed class DrawingAttributes: DependencyObject
    {
        public DrawingAttributes();
        public Color Color { get; set; }
        public double Height { get; set; }
        public Color OutlineColor { get; set; }
        public double Width { get; set; }
    }

    public sealed class Stroke: DependencyObject
    {
        public Stroke();
        public Stroke(StylusPointCollection stylusPoints);
        public DrawingAttributes DrawingAttributes { get; set; }
        public StylusPointCollection StylusPoints { get; set; }
        public Rect GetBounds();
        public bool HitTest(StylusPointCollection stylusPointCollection);
    }

    [DefaultMemberAttribute(..)]
    public sealed class StrokeCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public StrokeCollection();
        public Rect GetBounds();
        public StrokeCollection HitTest(StylusPointCollection stylusPointCollection);
    }

} 

namespace System.Windows.Input
{
    public sealed class Cursor
    {
        public override string ToString();
    }

    public abstract sealed class Cursors
    {
        public static Cursor Arrow { get; }
        public static Cursor Eraser { get; }
        public static Cursor Hand { get; }
        public static Cursor IBeam { get; }
        public static Cursor None { get; }
        public static Cursor SizeNS { get; }
        public static Cursor SizeWE { get; }
        public static Cursor Stylus { get; }
        public static Cursor Wait { get; }
    }

    public abstract sealed class FocusManager
    {
        public static object GetFocusedElement();
    }

    public interface ICommand
    {
        public bool CanExecute(object parameter);
        public void Execute(object parameter);
        public event EventHandler CanExecuteChanged;
    }

    public sealed class InputMethod: DependencyObject
    {
        public static readonly DependencyProperty IsInputMethodEnabledProperty;
        public static readonly DependencyProperty PreferredImeConversionModeProperty;
        public static readonly DependencyProperty PreferredImeStateProperty;
        public static bool GetIsInputMethodEnabled(DependencyObject target);
        public static ImeConversionModeValues GetPreferredImeConversionMode(DependencyObject target);
        public static InputMethodState GetPreferredImeState(DependencyObject target);
        public static void SetIsInputMethodEnabled(DependencyObject target, bool value);
        public static void SetPreferredImeConversionMode(DependencyObject target, ImeConversionModeValues value);
        public static void SetPreferredImeState(DependencyObject target, InputMethodState value);
    }

    public abstract sealed class Keyboard
    {
        public static ModifierKeys Modifiers { get; }
    }

    public sealed class StylusDevice
    {
        public TabletDeviceType DeviceType { get; }
        public bool Inverted { get; }
        public StylusPointCollection GetStylusPoints(UIElement relativeTo);
    }

    public struct StylusPoint
    {
        public StylusPoint(double x, double y);
        public float PressureFactor { get; set; }
        public double X { get; set; }
        public double Y { get; set; }
    }

    public sealed class TextComposition
    {
        public string CompositionText { get; }
    }

    public abstract sealed class Touch
    {
        public static event TouchFrameEventHandler FrameReported;
    }

    [ContentPropertyAttribute(..)]
    public sealed class TouchDevice: DependencyObject
    {
        public TouchDevice();
        public static readonly DependencyProperty DirectlyOverProperty;
        public static readonly DependencyProperty IdProperty;
        public UIElement DirectlyOver { get; }
        public int Id { get; }
    }

    public sealed class TouchPoint: DependencyObject
    {
        public TouchPoint();
        public static readonly DependencyProperty ActionProperty;
        public static readonly DependencyProperty PositionProperty;
        public static readonly DependencyProperty SizeProperty;
        public static readonly DependencyProperty TouchDeviceProperty;
        public TouchAction Action { get; }
        public Point Position { get; }
        public Size Size { get; }
        public TouchDevice TouchDevice { get; }
    }

    public enum ImeConversionModeValues
    {
        Alphanumeric,
        CharCode,
        DoNotCare,
        Eudc,
        Fixed,
        FullShape,
        Katakana,
        Native,
        NoConversion,
        Roman,
        Symbol,
    }

    public enum InputMethodState
    {
        DoNotCare,
        Off,
        On,
    }

    public enum Key
    {
        A,
        Add,
        Alt,
        B,
        Back,
        C,
        CapsLock,
        Ctrl,
        D,
        D0,
        D1,
        D2,
        D3,
        D4,
        D5,
        D6,
        D7,
        D8,
        D9,
        Decimal,
        Delete,
        Divide,
        Down,
        E,
        End,
        Enter,
        Escape,
        F,
        F1,
        F10,
        F11,
        F12,
        F2,
        F3,
        F4,
        F5,
        F6,
        F7,
        F8,
        F9,
        G,
        H,
        Home,
        I,
        Insert,
        J,
        K,
        L,
        Left,
        M,
        Multiply,
        N,
        None,
        NumPad0,
        NumPad1,
        NumPad2,
        NumPad3,
        NumPad4,
        NumPad5,
        NumPad6,
        NumPad7,
        NumPad8,
        NumPad9,
        O,
        P,
        PageDown,
        PageUp,
        Q,
        R,
        Right,
        S,
        Shift,
        Space,
        Subtract,
        T,
        Tab,
        U,
        Unknown,
        Up,
        V,
        W,
        X,
        Y,
        Z,
    }

    public enum KeyboardNavigationMode
    {
        Cycle,
        Local,
        Once,
    }

    [FlagsAttribute(..)]
    public enum ModifierKeys
    {
        Alt,
        Apple,
        Control,
        None,
        Shift,
        Windows,
    }

    public enum TabletDeviceType
    {
        Mouse,
        Stylus,
        Touch,
    }

    public enum TouchAction
    {
        Down,
        Move,
        Up,
    }

    [DefaultMemberAttribute(..)]
    public sealed class StylusPointCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public StylusPointCollection();
        public void Add(StylusPointCollection stylusPoints);
    }

    [DefaultMemberAttribute(..)]
    public sealed class TouchPointCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
    }

    public sealed class KeyEventArgs: RoutedEventArgs
    {
        public bool Handled { get; set; }
        public Key Key { get; }
        public int PlatformKeyCode { get; }
    }

    public delegate void KeyEventHandler(object sender, KeyEventArgs e);

    public sealed class MouseButtonEventArgs: MouseEventArgs
    {
        public bool Handled { get; set; }
    }

    public delegate void MouseButtonEventHandler(object sender, MouseButtonEventArgs e);

    public class MouseEventArgs: RoutedEventArgs
    {
        public StylusDevice StylusDevice { get; }
        public Point GetPosition(UIElement relativeTo);
    }

    public delegate void MouseEventHandler(object sender, MouseEventArgs e);

    public sealed class MouseWheelEventArgs: MouseEventArgs
    {
        public int Delta { get; }
        public bool Handled { get; set; }
    }

    public delegate void MouseWheelEventHandler(object sender, MouseWheelEventArgs e);

    public sealed class TextCompositionEventArgs: RoutedEventArgs
    {
        public bool Handled { get; set; }
        public string Text { get; }
        public TextComposition TextComposition { get; }
    }

    public delegate void TextCompositionEventHandler(object sender, TextCompositionEventArgs e);

    public sealed class TouchFrameEventArgs: EventArgs
    {
        public int Timestamp { get; }
        public TouchPoint GetPrimaryTouchPoint(UIElement relativeTo);
        public TouchPointCollection GetTouchPoints(UIElement relativeTo);
        public void SuspendMousePromotionUntilTouchUp();
    }

    public delegate void TouchFrameEventHandler(object sender, TouchFrameEventArgs e);

} 

namespace System.Windows.Interop
{
    public sealed class ComAutomationEvent
    {
        public void AddEventHandler(Delegate handler);
        public void RemoveEventHandler(Delegate handler);
        public event ComAutomationEventHandler EventRaised;
    }

    public class ComAutomationEventMetaObjectProvider: ComAutomationMetaObjectProviderBase, IDynamicMetaObjectProvider
    {
        public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, ref object result);
    }

    public abstract sealed class ComAutomationFactory
    {
        public static bool IsAvailable { get; }
        public static IDisposable CreateObject(string progID);
        public static ComAutomationEvent GetEvent(object comAutomationObject, string eventName);
        public static IDisposable GetObject(string progID);
    }

    public class ComAutomationMetaObjectProvider: ComAutomationMetaObjectProviderBase, IDisposable, IDynamicMetaObjectProvider
    {
        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, ref object result);
        public override bool TryGetMember(GetMemberBinder binder, ref object result);
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, ref object result);
        public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value);
        public override bool TrySetMember(SetMemberBinder binder, object value);
    }

    public class ComAutomationMetaObjectProviderAwaitingIndex: ComAutomationMetaObjectProvider, IDisposable, IDynamicMetaObjectProvider
    {
        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, ref object result);
        public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value);
    }

    public abstract class ComAutomationMetaObjectProviderBase: IDynamicMetaObjectProvider
    {
        public virtual IEnumerable`1<string> GetDynamicMemberNames();
        public DynamicMetaObject GetMetaObject(Expression parameter);
        public virtual bool TryBinaryOperation(BinaryOperationBinder binder, object arg, ref object result);
        public virtual bool TryConvert(ConvertBinder binder, ref object result);
        public virtual bool TryCreateInstance(CreateInstanceBinder binder, object[] args, ref object result);
        public virtual bool TryGetIndex(GetIndexBinder binder, object[] indexes, ref object result);
        public virtual bool TryGetMember(GetMemberBinder binder, ref object result);
        public virtual bool TryInvoke(InvokeBinder binder, object[] args, ref object result);
        public virtual bool TryInvokeMember(InvokeMemberBinder binder, object[] args, ref object result);
        public virtual bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value);
        public virtual bool TrySetMember(SetMemberBinder binder, object value);
        public virtual bool TryUnaryOperation(UnaryOperationBinder binder, ref object result);
    }

    public sealed class Content
    {
        public Content();
        public double ActualHeight { get; }
        public double ActualWidth { get; }
        public bool IsFullScreen { get; set; }
        public double ZoomFactor { get; }
        public event EventHandler FullScreenChanged;
        public event EventHandler Resized;
        public event EventHandler Zoomed;
    }

    public sealed class HostingRenderTargetBitmap
    {
        [SecurityCriticalAttribute(..)]
        public HostingRenderTargetBitmap(int width, int height, IntPtr bitmap);
        public Nullable`1<Rect> Render(UIElement visual);
    }

    public sealed class Settings
    {
        public Settings();
        public bool EnableAutoZoom { get; set; }
        public bool EnableCacheVisualization { get; set; }
        public bool EnableFrameRateCounter { get; set; }
        public bool EnableGPUAcceleration { get; }
        public bool EnableHTMLAccess { get; }
        public bool EnableRedrawRegions { get; set; }
        public int MaxFrameRate { get; set; }
        public bool Windowless { get; }
    }

    public class SilverlightHost
    {
        public SilverlightHost();
        public Color Background { get; }
        public Content Content { get; }
        public IDictionary`2<string,string> InitParams { get; }
        public bool IsLoaded { get; }
        public string NavigationState { get; set; }
        public Settings Settings { get; }
        public Uri Source { get; }
        public bool IsVersionSupported(string versionStr);
        public event EventHandler`1<NavigationStateChangedEventArgs> NavigationStateChanged;
    }

    public sealed class ComAutomationEventArgs: EventArgs
    {
        public object[] Arguments { get; set; }
    }

    public delegate void ComAutomationEventHandler(object sender, ComAutomationEventArgs e);

    public class NavigationStateChangedEventArgs: EventArgs
    {
        public NavigationStateChangedEventArgs(string previousNavigationState, string newNavigationState);
        public string NewNavigationState { get; }
        public string PreviousNavigationState { get; }
    }

} 

namespace System.Windows.Markup
{
    public abstract sealed class XamlReader
    {
        public static object Load(string xaml);
        [SecurityCriticalAttribute(..)]
        public static object LoadWithInitialTemplateValidation(string xaml);
    }

    public sealed class XmlLanguage
    {
        public string IetfLanguageTag { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
        public static XmlLanguage GetLanguage(string ietfLanguageTag);
        public static bool operator ==(XmlLanguage xmlLanguage1, XmlLanguage xmlLanguage2);
        public static bool operator !=(XmlLanguage xmlLanguage1, XmlLanguage xmlLanguage2);
    }

    [AttributeUsageAttribute(..)]
    public sealed class ContentPropertyAttribute: Attribute, _Attribute
    {
        public ContentPropertyAttribute();
        public ContentPropertyAttribute(string name);
        public string Name { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class XmlnsDefinitionAttribute: Attribute, _Attribute
    {
        public XmlnsDefinitionAttribute(string xmlNamespace, string clrNamespace);
        public string AssemblyName { get; set; }
        public string ClrNamespace { get; }
        public string XmlNamespace { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class XmlnsPrefixAttribute: Attribute, _Attribute
    {
        public XmlnsPrefixAttribute(string xmlNamespace, string prefix);
        public string Prefix { get; }
        public string XmlNamespace { get; }
    }

    public class XamlParseException: SystemException, _Exception, ISerializable
    {
        public int LineNumber { get; }
        public int LinePosition { get; }
    }

} 

namespace System.Windows.Media
{
    public sealed class ArcSegment: PathSegment
    {
        public ArcSegment();
        public static readonly DependencyProperty IsLargeArcProperty;
        public static readonly DependencyProperty PointProperty;
        public static readonly DependencyProperty RotationAngleProperty;
        public static readonly DependencyProperty SizeProperty;
        public static readonly DependencyProperty SweepDirectionProperty;
        public bool IsLargeArc { get; set; }
        public Point Point { get; set; }
        public double RotationAngle { get; set; }
        public Size Size { get; set; }
        public SweepDirection SweepDirection { get; set; }
    }

    public sealed class AudioCaptureDevice: CaptureDevice
    {
        public static readonly DependencyProperty AudioFrameSizeProperty;
        public int AudioFrameSize { get; set; }
        public AudioFormat DesiredFormat { get; set; }
        public Collection`1<AudioFormat> SupportedFormats { get; }
    }

    public class AudioFormat
    {
        public int BitsPerSample { get; }
        public int Channels { get; }
        public int SamplesPerSecond { get; }
        public WaveFormatType WaveFormat { get; }
    }

    public abstract class AudioSink
    {
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        public AudioSink();
        public CaptureSource CaptureSource { get; set; }
        protected override void Finalize();
        protected abstract void OnCaptureStarted();
        protected abstract void OnCaptureStopped();
        protected abstract void OnFormatChange(AudioFormat audioFormat);
        protected abstract void OnSamples(long sampleTime, long sampleDuration, byte[] sampleData);
    }

    public sealed class BezierSegment: PathSegment
    {
        public BezierSegment();
        public static readonly DependencyProperty Point1Property;
        public static readonly DependencyProperty Point2Property;
        public static readonly DependencyProperty Point3Property;
        public Point Point1 { get; set; }
        public Point Point2 { get; set; }
        public Point Point3 { get; set; }
    }

    public sealed class BitmapCache: CacheMode
    {
        public BitmapCache();
        public static readonly DependencyProperty RenderAtScaleProperty;
        public double RenderAtScale { get; set; }
    }

    public abstract class Brush: DependencyObject
    {
        protected Brush();
        public static readonly DependencyProperty OpacityProperty;
        public static readonly DependencyProperty RelativeTransformProperty;
        public static readonly DependencyProperty TransformProperty;
        public double Opacity { get; set; }
        public Transform RelativeTransform { get; set; }
        public Transform Transform { get; set; }
    }

    public abstract class CacheMode: DependencyObject
    {
        protected CacheMode();
    }

    public class CaptureDevice: DependencyObject
    {
        public static readonly DependencyProperty FriendlyNameProperty;
        public static readonly DependencyProperty IsDefaultDeviceProperty;
        public string FriendlyName { get; }
        public bool IsDefaultDevice { get; }
    }

    public abstract sealed class CaptureDeviceConfiguration
    {
        public static bool AllowedDeviceAccess { get; }
        public static Collection`1<AudioCaptureDevice> GetAvailableAudioCaptureDevices();
        public static Collection`1<VideoCaptureDevice> GetAvailableVideoCaptureDevices();
        public static AudioCaptureDevice GetDefaultAudioCaptureDevice();
        public static VideoCaptureDevice GetDefaultVideoCaptureDevice();
        public static bool RequestDeviceAccess();
    }

    public sealed class CaptureSource: DependencyObject
    {
        public CaptureSource();
        public static readonly DependencyProperty AudioCaptureDeviceProperty;
        public static readonly DependencyProperty VideoCaptureDeviceProperty;
        public AudioCaptureDevice AudioCaptureDevice { get; set; }
        public CaptureState State { get; }
        public VideoCaptureDevice VideoCaptureDevice { get; set; }
        public void AsyncCaptureImage(Action`1<WriteableBitmap> Callback);
        public void Start();
        public void Stop();
        public event EventHandler`1<ExceptionRoutedEventArgs> CaptureFailed;
    }

    public struct Color: IFormattable
    {
        public byte A { get; set; }
        public byte B { get; set; }
        public byte G { get; set; }
        public byte R { get; set; }
        public bool Equals(Color color);
        public override bool Equals(object o);
        public static Color FromArgb(byte a, byte r, byte g, byte b);
        public override int GetHashCode();
        public override string ToString();
        public string ToString(IFormatProvider provider);
        public static bool operator ==(Color color1, Color color2);
        public static bool operator !=(Color color1, Color color2);
    }

    public sealed class Colors
    {
        public static Color Black { get; }
        public static Color Blue { get; }
        public static Color Brown { get; }
        public static Color Cyan { get; }
        public static Color DarkGray { get; }
        public static Color Gray { get; }
        public static Color Green { get; }
        public static Color LightGray { get; }
        public static Color Magenta { get; }
        public static Color Orange { get; }
        public static Color Purple { get; }
        public static Color Red { get; }
        public static Color Transparent { get; }
        public static Color White { get; }
        public static Color Yellow { get; }
    }

    public sealed class CompositeTransform: Transform
    {
        public CompositeTransform();
        public static readonly DependencyProperty CenterXProperty;
        public static readonly DependencyProperty CenterYProperty;
        public static readonly DependencyProperty RotationProperty;
        public static readonly DependencyProperty ScaleXProperty;
        public static readonly DependencyProperty ScaleYProperty;
        public static readonly DependencyProperty SkewXProperty;
        public static readonly DependencyProperty SkewYProperty;
        public static readonly DependencyProperty TranslateXProperty;
        public static readonly DependencyProperty TranslateYProperty;
        public double CenterX { get; set; }
        public double CenterY { get; set; }
        public double Rotation { get; set; }
        public double ScaleX { get; set; }
        public double ScaleY { get; set; }
        public double SkewX { get; set; }
        public double SkewY { get; set; }
        public double TranslateX { get; set; }
        public double TranslateY { get; set; }
    }

    public abstract sealed class CompositionTarget
    {
        public static event EventHandler Rendering;
    }

    public sealed class DeepZoomImageTileSource: MultiScaleTileSource
    {
        public DeepZoomImageTileSource();
        public DeepZoomImageTileSource(Uri sourceUri);
        public static readonly DependencyProperty UriSourceProperty;
        public Uri UriSource { get; set; }
        protected override void GetTileLayers(int tileLevel, int tilePositionX, int tilePositionY, IList`1<object> tileImageLayerSources);
    }

    public class DomainAcquirer
    {
        public DomainAcquirer();
        public string CustomData { get; set; }
        public void DomainJoinAsyncCancel();
        public void DomainLeaveAsyncCancel();
        public void JoinDomainAsync(Guid serviceId, Guid accountId, Uri domainServerUrl, string friendlyName);
        public void LeaveDomainAsync(Guid serviceId, Guid accountId, Uri domainServerUrl);
        protected virtual void OnCancel();
        protected virtual void OnJoinDomain(Stream joinChallenge, Uri domainServerUri);
        protected virtual void OnLeaveDomain(Stream leaveChallenge, Uri domainServerUri);
        protected void SetJoinDomainResponse(Stream domainResponse);
        protected void SetLeaveDomainResponse(Stream domainResponse);
        public event EventHandler`1<DomainOperationCompletedEventArgs> DomainOperationCompleted;
    }

    public sealed class EllipseGeometry: Geometry
    {
        public EllipseGeometry();
        public static readonly DependencyProperty CenterProperty;
        public static readonly DependencyProperty RadiusXProperty;
        public static readonly DependencyProperty RadiusYProperty;
        public Point Center { get; set; }
        public double RadiusX { get; set; }
        public double RadiusY { get; set; }
    }

    public class FontFamily
    {
        public FontFamily(string familyName);
        public string Source { get; }
        public override bool Equals(object o);
        public override int GetHashCode();
        public override string ToString();
    }

    public abstract class GeneralTransform: DependencyObject
    {
        protected GeneralTransform();
        public abstract GeneralTransform Inverse { get; }
        public Point Transform(Point point);
        public abstract Rect TransformBounds(Rect rect);
        public abstract bool TryTransform(Point inPoint, ref Point outPoint);
    }

    public abstract class Geometry: DependencyObject
    {
        public static readonly DependencyProperty TransformProperty;
        public Rect Bounds { get; }
        public static Geometry Empty { get; }
        public static double StandardFlatteningTolerance { get; }
        public Transform Transform { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class GeometryGroup: Geometry
    {
        public GeometryGroup();
        public static readonly DependencyProperty ChildrenProperty;
        public static readonly DependencyProperty FillRuleProperty;
        public GeometryCollection Children { get; set; }
        public FillRule FillRule { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public abstract class GradientBrush: Brush
    {
        protected GradientBrush();
        public static readonly DependencyProperty ColorInterpolationModeProperty;
        public static readonly DependencyProperty GradientStopsProperty;
        public static readonly DependencyProperty MappingModeProperty;
        public static readonly DependencyProperty SpreadMethodProperty;
        public ColorInterpolationMode ColorInterpolationMode { get; set; }
        public GradientStopCollection GradientStops { get; set; }
        public BrushMappingMode MappingMode { get; set; }
        public GradientSpreadMethod SpreadMethod { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class GradientStop: DependencyObject
    {
        public GradientStop();
        public static readonly DependencyProperty ColorProperty;
        public static readonly DependencyProperty OffsetProperty;
        public Color Color { get; set; }
        public double Offset { get; set; }
    }

    public sealed class ImageBrush: TileBrush
    {
        public ImageBrush();
        public static readonly DependencyProperty ImageSourceProperty;
        public ImageSource ImageSource { get; set; }
        public event EventHandler`1<ExceptionRoutedEventArgs> ImageFailed;
        public event EventHandler`1<RoutedEventArgs> ImageOpened;
    }

    [TypeConverterAttribute(..)]
    public abstract class ImageSource: DependencyObject
    {
    }

    public sealed class ImageSourceConverter: TypeConverter
    {
        public ImageSourceConverter();
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
    }

    public sealed class ImplicitInputBrush: Brush
    {
        public ImplicitInputBrush();
    }

    public class LicenseAcquirer
    {
        public LicenseAcquirer();
        public string CustomData { get; set; }
        public DomainAcquirer DomainAcquirer { get; set; }
        public Uri LicenseServerUriOverride { get; set; }
        public void AcquireLicenseAsync(Guid keyId, ContentKeyType keyType, Guid serviceId);
        public void AcquireLicenseAsync(Stream mediaStream);
        public void AcquireLicenseAsyncCancel();
        protected virtual void OnAcquireLicense(Stream licenseChallenge, Uri licenseServerUri);
        protected virtual void OnCancel();
        protected void SetLicenseResponse(Stream licenseResponse);
        public event EventHandler`1<AcquireLicenseCompletedEventArgs> AcquireLicenseCompleted;
    }

    public abstract sealed class LicenseManagement
    {
        public static IEnumerator`1<MediaLicense> SelectLicenses(Guid keyId);
        public static IEnumerator`1<MediaLicense> SelectLicenses(Stream mediaStream);
    }

    [ContentPropertyAttribute(..)]
    public sealed class LinearGradientBrush: GradientBrush
    {
        public LinearGradientBrush();
        public LinearGradientBrush(GradientStopCollection gradientStopCollection, double angle);
        public static readonly DependencyProperty EndPointProperty;
        public static readonly DependencyProperty StartPointProperty;
        public Point EndPoint { get; set; }
        public Point StartPoint { get; set; }
    }

    public sealed class LineGeometry: Geometry
    {
        public LineGeometry();
        public static readonly DependencyProperty EndPointProperty;
        public static readonly DependencyProperty StartPointProperty;
        public Point EndPoint { get; set; }
        public Point StartPoint { get; set; }
    }

    public sealed class LineSegment: PathSegment
    {
        public LineSegment();
        public static readonly DependencyProperty PointProperty;
        public Point Point { get; set; }
    }

    public struct Matrix: IFormattable
    {
        public Matrix(double m11, double m12, double m21, double m22, double offsetX, double offsetY);
        public static Matrix Identity { get; }
        public bool IsIdentity { get; }
        public double M11 { get; set; }
        public double M12 { get; set; }
        public double M21 { get; set; }
        public double M22 { get; set; }
        public double OffsetX { get; set; }
        public double OffsetY { get; set; }
        public bool Equals(Matrix value);
        public override bool Equals(object o);
        public override int GetHashCode();
        public override string ToString();
        public string ToString(IFormatProvider provider);
        public Point Transform(Point point);
        public static bool operator ==(Matrix matrix1, Matrix matrix2);
        public static bool operator !=(Matrix matrix1, Matrix matrix2);
    }

    [ContentPropertyAttribute(..)]
    public sealed class Matrix3DProjection: Projection
    {
        public Matrix3DProjection();
        public static readonly DependencyProperty ProjectionMatrixProperty;
        public Matrix3D ProjectionMatrix { get; set; }
    }

    public sealed class MatrixTransform: Transform
    {
        public MatrixTransform();
        public static readonly DependencyProperty MatrixProperty;
        public Matrix Matrix { get; set; }
    }

    public class MediaLicense
    {
        public DateTime ExpirationDate { get; }
        public Guid KeyId { get; }
        public Guid UplinkKeyId { get; }
        public bool Usable { get; }
    }

    public class MediaStreamDescription
    {
        public MediaStreamDescription(MediaStreamType type, IDictionary`2<MediaStreamAttributeKeys,string> mediaStreamAttributes);
        public IDictionary`2<MediaStreamAttributeKeys,string> MediaAttributes { get; }
        public int StreamId { get; }
        public MediaStreamType Type { get; }
    }

    public class MediaStreamSample
    {
        public MediaStreamSample(MediaStreamDescription mediaStreamDescription, Stream stream, long offset, long count, long timestamp, IDictionary`2<MediaSampleAttributeKeys,string> attributes);
        public MediaStreamSample(MediaStreamDescription mediaStreamDescription, Stream stream, long offset, long count, long timestamp, long duration, IDictionary`2<MediaSampleAttributeKeys,string> attributes);
        public IDictionary`2<MediaSampleAttributeKeys,string> Attributes { get; }
        public long Count { get; }
        public long Duration { get; }
        public MediaStreamDescription MediaStreamDescription { get; }
        public long Offset { get; }
        public Stream Stream { get; }
        public long Timestamp { get; }
    }

    public abstract class MediaStreamSource
    {
        protected MediaStreamSource();
        protected int AudioBufferLength { get; set; }
        protected abstract void CloseMedia();
        protected void ErrorOccurred(string errorDescription);
        protected abstract void GetDiagnosticAsync(MediaStreamSourceDiagnosticKind diagnosticKind);
        protected abstract void GetSampleAsync(MediaStreamType mediaStreamType);
        protected abstract void OpenMediaAsync();
        protected void ReportGetDiagnosticCompleted(MediaStreamSourceDiagnosticKind diagnosticKind, long diagnosticValue);
        protected void ReportGetSampleCompleted(MediaStreamSample mediaStreamSample);
        protected void ReportGetSampleProgress(double bufferingProgress);
        protected void ReportOpenMediaCompleted(IDictionary`2<MediaSourceAttributesKeys,string> mediaStreamAttributes, IEnumerable`1<MediaStreamDescription> availableMediaStreams);
        protected void ReportSeekCompleted(long timeSeekedTo);
        protected void ReportSwitchMediaStreamCompleted(MediaStreamDescription mediaStreamDescription);
        protected abstract void SeekAsync(long seekToTime);
        protected abstract void SwitchMediaStreamAsync(MediaStreamDescription mediaStreamDescription);
    }

    public abstract class MultiScaleTileSource: DependencyObject
    {
        public MultiScaleTileSource(int imageWidth, int imageHeight, int tileWidth, int tileHeight, int tileOverlap);
        public MultiScaleTileSource(long imageWidth, long imageHeight, int tileWidth, int tileHeight, int tileOverlap);
        protected TimeSpan TileBlendTime { get; set; }
        protected abstract void GetTileLayers(int tileLevel, int tilePositionX, int tilePositionY, IList`1<object> tileImageLayerSources);
        protected void InvalidateTileLayer(int level, int tilePositionX, int tilePositionY, int tileLayer);
    }

    [ContentPropertyAttribute(..)]
    public sealed class PathFigure: DependencyObject
    {
        public PathFigure();
        public static readonly DependencyProperty IsClosedProperty;
        public static readonly DependencyProperty IsFilledProperty;
        public static readonly DependencyProperty SegmentsProperty;
        public static readonly DependencyProperty StartPointProperty;
        public bool IsClosed { get; set; }
        public bool IsFilled { get; set; }
        public PathSegmentCollection Segments { get; set; }
        public Point StartPoint { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class PathGeometry: Geometry
    {
        public PathGeometry();
        public static readonly DependencyProperty FiguresProperty;
        public static readonly DependencyProperty FillRuleProperty;
        public PathFigureCollection Figures { get; set; }
        public FillRule FillRule { get; set; }
    }

    public abstract class PathSegment: DependencyObject
    {
    }

    public sealed class PlaneProjection: Projection
    {
        public PlaneProjection();
        public static readonly DependencyProperty CenterOfRotationXProperty;
        public static readonly DependencyProperty CenterOfRotationYProperty;
        public static readonly DependencyProperty CenterOfRotationZProperty;
        public static readonly DependencyProperty GlobalOffsetXProperty;
        public static readonly DependencyProperty GlobalOffsetYProperty;
        public static readonly DependencyProperty GlobalOffsetZProperty;
        public static readonly DependencyProperty LocalOffsetXProperty;
        public static readonly DependencyProperty LocalOffsetYProperty;
        public static readonly DependencyProperty LocalOffsetZProperty;
        public static readonly DependencyProperty ProjectionMatrixProperty;
        public static readonly DependencyProperty RotationXProperty;
        public static readonly DependencyProperty RotationYProperty;
        public static readonly DependencyProperty RotationZProperty;
        public double CenterOfRotationX { get; set; }
        public double CenterOfRotationY { get; set; }
        public double CenterOfRotationZ { get; set; }
        public double GlobalOffsetX { get; set; }
        public double GlobalOffsetY { get; set; }
        public double GlobalOffsetZ { get; set; }
        public double LocalOffsetX { get; set; }
        public double LocalOffsetY { get; set; }
        public double LocalOffsetZ { get; set; }
        public Matrix3D ProjectionMatrix { get; }
        public double RotationX { get; set; }
        public double RotationY { get; set; }
        public double RotationZ { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class PolyBezierSegment: PathSegment
    {
        public PolyBezierSegment();
        public static readonly DependencyProperty PointsProperty;
        public PointCollection Points { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class PolyLineSegment: PathSegment
    {
        public PolyLineSegment();
        public static readonly DependencyProperty PointsProperty;
        public PointCollection Points { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class PolyQuadraticBezierSegment: PathSegment
    {
        public PolyQuadraticBezierSegment();
        public static readonly DependencyProperty PointsProperty;
        public PointCollection Points { get; set; }
    }

    public abstract class Projection: DependencyObject
    {
        protected Projection();
    }

    public sealed class QuadraticBezierSegment: PathSegment
    {
        public QuadraticBezierSegment();
        public static readonly DependencyProperty Point1Property;
        public static readonly DependencyProperty Point2Property;
        public Point Point1 { get; set; }
        public Point Point2 { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class RadialGradientBrush: GradientBrush
    {
        public RadialGradientBrush();
        public RadialGradientBrush(Color startColor, Color endColor);
        public RadialGradientBrush(GradientStopCollection gradientStopCollection);
        public static readonly DependencyProperty CenterProperty;
        public static readonly DependencyProperty GradientOriginProperty;
        public static readonly DependencyProperty RadiusXProperty;
        public static readonly DependencyProperty RadiusYProperty;
        public Point Center { get; set; }
        public Point GradientOrigin { get; set; }
        public double RadiusX { get; set; }
        public double RadiusY { get; set; }
    }

    public sealed class RectangleGeometry: Geometry
    {
        public RectangleGeometry();
        public static readonly DependencyProperty RadiusXProperty;
        public static readonly DependencyProperty RadiusYProperty;
        public static readonly DependencyProperty RectProperty;
        public double RadiusX { get; set; }
        public double RadiusY { get; set; }
        public Rect Rect { get; set; }
    }

    public sealed class RotateTransform: Transform
    {
        public RotateTransform();
        public static readonly DependencyProperty AngleProperty;
        public static readonly DependencyProperty CenterXProperty;
        public static readonly DependencyProperty CenterYProperty;
        public double Angle { get; set; }
        public double CenterX { get; set; }
        public double CenterY { get; set; }
    }

    public sealed class ScaleTransform: Transform
    {
        public ScaleTransform();
        public static readonly DependencyProperty CenterXProperty;
        public static readonly DependencyProperty CenterYProperty;
        public static readonly DependencyProperty ScaleXProperty;
        public static readonly DependencyProperty ScaleYProperty;
        public double CenterX { get; set; }
        public double CenterY { get; set; }
        public double ScaleX { get; set; }
        public double ScaleY { get; set; }
    }

    public sealed class SkewTransform: Transform
    {
        public SkewTransform();
        public static readonly DependencyProperty AngleXProperty;
        public static readonly DependencyProperty AngleYProperty;
        public static readonly DependencyProperty CenterXProperty;
        public static readonly DependencyProperty CenterYProperty;
        public double AngleX { get; set; }
        public double AngleY { get; set; }
        public double CenterX { get; set; }
        public double CenterY { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class SolidColorBrush: Brush
    {
        public SolidColorBrush();
        public SolidColorBrush(Color color);
        public static readonly DependencyProperty ColorProperty;
        public Color Color { get; set; }
    }

    public abstract sealed class TextOptions
    {
        public static readonly DependencyProperty TextHintingModeProperty;
        public static TextHintingMode GetTextHintingMode(FrameworkElement target);
        public static void SetTextHintingMode(FrameworkElement target, TextHintingMode textHintingMode);
    }

    public abstract class TileBrush: Brush
    {
        protected TileBrush();
        public static readonly DependencyProperty AlignmentXProperty;
        public static readonly DependencyProperty AlignmentYProperty;
        public static readonly DependencyProperty StretchProperty;
        public AlignmentX AlignmentX { get; set; }
        public AlignmentY AlignmentY { get; set; }
        public Stretch Stretch { get; set; }
    }

    public sealed class TimelineMarker: DependencyObject
    {
        public TimelineMarker();
        public static readonly DependencyProperty TextProperty;
        public static readonly DependencyProperty TimeProperty;
        public static readonly DependencyProperty TypeProperty;
        public string Text { get; set; }
        public TimeSpan Time { get; set; }
        public string Type { get; set; }
    }

    public abstract class Transform: GeneralTransform
    {
        public override Rect TransformBounds(Rect rect);
        public override bool TryTransform(Point inPoint, ref Point outPoint);
    }

    [ContentPropertyAttribute(..)]
    public sealed class TransformGroup: Transform
    {
        public TransformGroup();
        public static readonly DependencyProperty ChildrenProperty;
        public TransformCollection Children { get; set; }
        public Matrix Value { get; }
    }

    public sealed class TranslateTransform: Transform
    {
        public TranslateTransform();
        public static readonly DependencyProperty XProperty;
        public static readonly DependencyProperty YProperty;
        public double X { get; set; }
        public double Y { get; set; }
    }

    public sealed class VideoBrush: TileBrush
    {
        public VideoBrush();
        public static readonly DependencyProperty SourceNameProperty;
        public string SourceName { get; set; }
        public void SetSource(CaptureSource source);
        public void SetSource(MediaElement source);
    }

    public sealed class VideoCaptureDevice: CaptureDevice
    {
        public VideoFormat DesiredFormat { get; set; }
        public Collection`1<VideoFormat> SupportedFormats { get; }
    }

    public class VideoFormat
    {
        public float FramesPerSecond { get; }
        public int Height { get; }
        public PixelFormatType PixelFormat { get; }
        public int Stride { get; }
        public int Width { get; }
    }

    public abstract class VideoSink
    {
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        public VideoSink();
        public CaptureSource CaptureSource { get; set; }
        protected override void Finalize();
        protected abstract void OnCaptureStarted();
        protected abstract void OnCaptureStopped();
        protected abstract void OnFormatChange(VideoFormat videoFormat);
        protected abstract void OnSample(long sampleTime, long frameDuration, byte[] sampleData);
    }

    public abstract sealed class VisualTreeHelper
    {
        public static IEnumerable`1<UIElement> FindElementsInHostCoordinates(Point intersectingPoint, UIElement subtree);
        public static IEnumerable`1<UIElement> FindElementsInHostCoordinates(Rect intersectingRect, UIElement subtree);
        public static DependencyObject GetChild(DependencyObject reference, int childIndex);
        public static int GetChildrenCount(DependencyObject reference);
        public static DependencyObject GetParent(DependencyObject reference);
    }

    public enum AlignmentX
    {
        Center,
        Left,
        Right,
    }

    public enum AlignmentY
    {
        Bottom,
        Center,
        Top,
    }

    public enum BrushMappingMode
    {
        Absolute,
        RelativeToBoundingBox,
    }

    public enum CaptureState
    {
        Failed,
        Started,
        Stopped,
    }

    public enum ColorInterpolationMode
    {
        ScRgbLinearInterpolation,
        SRgbLinearInterpolation,
    }

    public enum ContentKeyType
    {
        AES128Bit,
        Cocktail,
    }

    public enum FillRule
    {
        EvenOdd,
        Nonzero,
    }

    public enum GradientSpreadMethod
    {
        Pad,
        Reflect,
        Repeat,
    }

    public enum LogSource
    {
        EndOfStream,
        MediaElementShutdown,
        Pause,
        RequestLog,
        RuntimeShutdown,
        Seek,
        SourceChanged,
        Stop,
    }

    public enum MediaElementState
    {
        AcquiringLicense,
        Buffering,
        Closed,
        Individualizing,
        Opening,
        Paused,
        Playing,
        Stopped,
    }

    public enum MediaSampleAttributeKeys
    {
        DRMInitializationVector,
        FrameHeight,
        FrameWidth,
        KeyFrameFlag,
    }

    public enum MediaSourceAttributesKeys
    {
        CanSeek,
        DRMHeader,
        Duration,
    }

    public enum MediaStreamAttributeKeys
    {
        CodecPrivateData,
        Height,
        VideoFourCC,
        Width,
    }

    public enum MediaStreamSourceDiagnosticKind
    {
        BufferLevelInBytes,
        BufferLevelInMilliseconds,
    }

    public enum MediaStreamType
    {
        Audio,
        Script,
        Video,
    }

    public enum PenLineCap
    {
        Flat,
        Round,
        Square,
        Triangle,
    }

    public enum PenLineJoin
    {
        Bevel,
        Miter,
        Round,
    }

    public enum PixelFormatType
    {
        Format32bppArgb,
        Unknown,
    }

    public enum Stretch
    {
        Fill,
        None,
        Uniform,
        UniformToFill,
    }

    [FlagsAttribute(..)]
    public enum StyleSimulations
    {
        BoldItalicSimulation,
        BoldSimulation,
        ItalicSimulation,
        None,
    }

    public enum SweepDirection
    {
        Clockwise,
        Counterclockwise,
    }

    public enum TextHintingMode
    {
        Animated,
        Fixed,
    }

    public enum WaveFormatType
    {
        PCM,
    }

    [DefaultMemberAttribute(..)]
    public sealed class AudioCaptureDeviceCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
    }

    [DefaultMemberAttribute(..)]
    public sealed class DoubleCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public DoubleCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class GeometryCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public GeometryCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class GradientStopCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public GradientStopCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class PathFigureCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public PathFigureCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class PathSegmentCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public PathSegmentCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class PointCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public PointCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class TimelineMarkerCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public TimelineMarkerCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class TransformCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public TransformCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class VideoCaptureDeviceCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
    }

    public class AcquireLicenseCompletedEventArgs: AsyncCompletedEventArgs
    {
        public string CustomData { get; }
    }

    public class DomainOperationCompletedEventArgs: AsyncCompletedEventArgs
    {
        public Guid AccountId { get; }
        public string CustomData { get; }
        public bool IsDomainJoin { get; }
        public Guid ServiceId { get; }
    }

    public sealed class LogReadyRoutedEventArgs: RoutedEventArgs
    {
        public LogReadyRoutedEventArgs();
        public string Log { get; }
        public LogSource LogSource { get; }
    }

    public delegate void LogReadyRoutedEventHandler(object sender, LogReadyRoutedEventArgs e);

    public sealed class RenderingEventArgs: EventArgs
    {
        public TimeSpan RenderingTime { get; }
    }

    public sealed class TimelineMarkerRoutedEventArgs: RoutedEventArgs
    {
        public TimelineMarkerRoutedEventArgs();
        public TimelineMarker Marker { get; set; }
    }

    public delegate void TimelineMarkerRoutedEventHandler(object sender, TimelineMarkerRoutedEventArgs e);

} 

namespace System.Windows.Media.Animation
{
    public class BackEase: EasingFunctionBase, IEasingFunction
    {
        public BackEase();
        public static readonly DependencyProperty AmplitudeProperty;
        public double Amplitude { get; set; }
        protected override double EaseInCore(double normalizedTime);
    }

    [ContentPropertyAttribute(..)]
    public sealed class BeginStoryboard: TriggerAction
    {
        public BeginStoryboard();
        public static readonly DependencyProperty StoryboardProperty;
        public Storyboard Storyboard { get; set; }
    }

    public class BounceEase: EasingFunctionBase, IEasingFunction
    {
        public BounceEase();
        public static readonly DependencyProperty BouncesProperty;
        public static readonly DependencyProperty BouncinessProperty;
        public int Bounces { get; set; }
        public double Bounciness { get; set; }
        protected override double EaseInCore(double normalizedTime);
    }

    public class CircleEase: EasingFunctionBase, IEasingFunction
    {
        public CircleEase();
        protected override double EaseInCore(double normalizedTime);
    }

    public sealed class ColorAnimation: Timeline
    {
        public ColorAnimation();
        public static readonly DependencyProperty ByProperty;
        public static readonly DependencyProperty EasingFunctionProperty;
        public static readonly DependencyProperty FromProperty;
        public static readonly DependencyProperty ToProperty;
        public Nullable`1<Color> By { get; set; }
        public IEasingFunction EasingFunction { get; set; }
        public Nullable`1<Color> From { get; set; }
        public Nullable`1<Color> To { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class ColorAnimationUsingKeyFrames: Timeline
    {
        public ColorAnimationUsingKeyFrames();
        public ColorKeyFrameCollection KeyFrames { get; }
    }

    public abstract class ColorKeyFrame: DependencyObject
    {
        protected ColorKeyFrame();
        public static readonly DependencyProperty KeyTimeProperty;
        public static readonly DependencyProperty ValueProperty;
        public KeyTime KeyTime { get; set; }
        public Color Value { get; set; }
    }

    public class CubicEase: EasingFunctionBase, IEasingFunction
    {
        public CubicEase();
        protected override double EaseInCore(double normalizedTime);
    }

    public sealed class DiscreteColorKeyFrame: ColorKeyFrame
    {
        public DiscreteColorKeyFrame();
    }

    public sealed class DiscreteDoubleKeyFrame: DoubleKeyFrame
    {
        public DiscreteDoubleKeyFrame();
    }

    public sealed class DiscreteObjectKeyFrame: ObjectKeyFrame
    {
        public DiscreteObjectKeyFrame();
    }

    public sealed class DiscretePointKeyFrame: PointKeyFrame
    {
        public DiscretePointKeyFrame();
    }

    public sealed class DoubleAnimation: Timeline
    {
        public DoubleAnimation();
        public static readonly DependencyProperty ByProperty;
        public static readonly DependencyProperty EasingFunctionProperty;
        public static readonly DependencyProperty FromProperty;
        public static readonly DependencyProperty ToProperty;
        public Nullable`1<double> By { get; set; }
        public IEasingFunction EasingFunction { get; set; }
        public Nullable`1<double> From { get; set; }
        public Nullable`1<double> To { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class DoubleAnimationUsingKeyFrames: Timeline
    {
        public DoubleAnimationUsingKeyFrames();
        public DoubleKeyFrameCollection KeyFrames { get; }
    }

    public abstract class DoubleKeyFrame: DependencyObject
    {
        protected DoubleKeyFrame();
        public static readonly DependencyProperty KeyTimeProperty;
        public static readonly DependencyProperty ValueProperty;
        public KeyTime KeyTime { get; set; }
        public double Value { get; set; }
    }

    public sealed class EasingColorKeyFrame: ColorKeyFrame
    {
        public EasingColorKeyFrame();
        public static readonly DependencyProperty EasingFunctionProperty;
        public IEasingFunction EasingFunction { get; set; }
    }

    public sealed class EasingDoubleKeyFrame: DoubleKeyFrame
    {
        public EasingDoubleKeyFrame();
        public static readonly DependencyProperty EasingFunctionProperty;
        public IEasingFunction EasingFunction { get; set; }
    }

    public abstract class EasingFunctionBase: DependencyObject, IEasingFunction
    {
        [SecurityCriticalAttribute(..)]
        protected EasingFunctionBase();
        public static readonly DependencyProperty EasingModeProperty;
        public EasingMode EasingMode { get; set; }
        public double Ease(double normalizedTime);
        protected abstract double EaseInCore(double normalizedTime);
    }

    public sealed class EasingPointKeyFrame: PointKeyFrame
    {
        public EasingPointKeyFrame();
        public static readonly DependencyProperty EasingFunctionProperty;
        public IEasingFunction EasingFunction { get; set; }
    }

    public class ElasticEase: EasingFunctionBase, IEasingFunction
    {
        public ElasticEase();
        public static readonly DependencyProperty OscillationsProperty;
        public static readonly DependencyProperty SpringinessProperty;
        public int Oscillations { get; set; }
        public double Springiness { get; set; }
        protected override double EaseInCore(double normalizedTime);
    }

    public class ExponentialEase: EasingFunctionBase, IEasingFunction
    {
        public ExponentialEase();
        public static readonly DependencyProperty ExponentProperty;
        public double Exponent { get; set; }
        protected override double EaseInCore(double normalizedTime);
    }

    public interface IEasingFunction
    {
        public double Ease(double normalizedTime);
    }

    public sealed class KeySpline: DependencyObject
    {
        public KeySpline();
        public Point ControlPoint1 { get; set; }
        public Point ControlPoint2 { get; set; }
    }

    public struct KeyTime
    {
        public TimeSpan TimeSpan { get; }
        public KeyTimeType Type { get; }
        public static KeyTime Uniform { get; }
        public bool Equals(KeyTime value);
        public static bool Equals(KeyTime keyTime1, KeyTime keyTime2);
        public override bool Equals(object value);
        public static KeyTime FromTimeSpan(TimeSpan timeSpan);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(KeyTime keyTime1, KeyTime keyTime2);
        public static bool operator !=(KeyTime keyTime1, KeyTime keyTime2);
        public static implicit operator KeyTime(TimeSpan timeSpan);
    }

    public sealed class LinearColorKeyFrame: ColorKeyFrame
    {
        public LinearColorKeyFrame();
    }

    public sealed class LinearDoubleKeyFrame: DoubleKeyFrame
    {
        public LinearDoubleKeyFrame();
    }

    public sealed class LinearPointKeyFrame: PointKeyFrame
    {
        public LinearPointKeyFrame();
    }

    [ContentPropertyAttribute(..)]
    public sealed class ObjectAnimationUsingKeyFrames: Timeline
    {
        public ObjectAnimationUsingKeyFrames();
        public ObjectKeyFrameCollection KeyFrames { get; }
    }

    public abstract class ObjectKeyFrame: DependencyObject
    {
        protected ObjectKeyFrame();
        public static readonly DependencyProperty KeyTimeProperty;
        public static readonly DependencyProperty ValueProperty;
        public KeyTime KeyTime { get; set; }
        public object Value { get; set; }
    }

    public sealed class PointAnimation: Timeline
    {
        public PointAnimation();
        public static readonly DependencyProperty ByProperty;
        public static readonly DependencyProperty EasingFunctionProperty;
        public static readonly DependencyProperty FromProperty;
        public static readonly DependencyProperty ToProperty;
        public Nullable`1<Point> By { get; set; }
        public IEasingFunction EasingFunction { get; set; }
        public Nullable`1<Point> From { get; set; }
        public Nullable`1<Point> To { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class PointAnimationUsingKeyFrames: Timeline
    {
        public PointAnimationUsingKeyFrames();
        public PointKeyFrameCollection KeyFrames { get; }
    }

    public abstract class PointKeyFrame: DependencyObject
    {
        protected PointKeyFrame();
        public static readonly DependencyProperty KeyTimeProperty;
        public static readonly DependencyProperty ValueProperty;
        public KeyTime KeyTime { get; set; }
        public Point Value { get; set; }
    }

    public class PowerEase: EasingFunctionBase, IEasingFunction
    {
        public PowerEase();
        public static readonly DependencyProperty PowerProperty;
        public double Power { get; set; }
        protected override double EaseInCore(double normalizedTime);
    }

    public class QuadraticEase: EasingFunctionBase, IEasingFunction
    {
        public QuadraticEase();
        protected override double EaseInCore(double normalizedTime);
    }

    public class QuarticEase: EasingFunctionBase, IEasingFunction
    {
        public QuarticEase();
        protected override double EaseInCore(double normalizedTime);
    }

    public class QuinticEase: EasingFunctionBase, IEasingFunction
    {
        public QuinticEase();
        protected override double EaseInCore(double normalizedTime);
    }

    public struct RepeatBehavior: IFormattable
    {
        public RepeatBehavior(double count);
        public RepeatBehavior(TimeSpan duration);
        public double Count { get; }
        public TimeSpan Duration { get; }
        public static RepeatBehavior Forever { get; }
        public bool HasCount { get; }
        public bool HasDuration { get; }
        public override bool Equals(object value);
        public bool Equals(RepeatBehavior repeatBehavior);
        public static bool Equals(RepeatBehavior repeatBehavior1, RepeatBehavior repeatBehavior2);
        public override int GetHashCode();
        public override string ToString();
        public string ToString(IFormatProvider formatProvider);
        public static bool operator ==(RepeatBehavior repeatBehavior1, RepeatBehavior repeatBehavior2);
        public static bool operator !=(RepeatBehavior repeatBehavior1, RepeatBehavior repeatBehavior2);
    }

    public class SineEase: EasingFunctionBase, IEasingFunction
    {
        public SineEase();
        protected override double EaseInCore(double normalizedTime);
    }

    public sealed class SplineColorKeyFrame: ColorKeyFrame
    {
        public SplineColorKeyFrame();
        public static readonly DependencyProperty KeySplineProperty;
        public KeySpline KeySpline { get; set; }
    }

    public sealed class SplineDoubleKeyFrame: DoubleKeyFrame
    {
        public SplineDoubleKeyFrame();
        public static readonly DependencyProperty KeySplineProperty;
        public KeySpline KeySpline { get; set; }
    }

    public sealed class SplinePointKeyFrame: PointKeyFrame
    {
        public SplinePointKeyFrame();
        public static readonly DependencyProperty KeySplineProperty;
        public KeySpline KeySpline { get; set; }
    }

    [ContentPropertyAttribute(..)]
    public sealed class Storyboard: Timeline
    {
        public Storyboard();
        public static readonly DependencyProperty TargetNameProperty;
        public static readonly DependencyProperty TargetPropertyProperty;
        public TimelineCollection Children { get; }
        public void Begin();
        public ClockState GetCurrentState();
        public TimeSpan GetCurrentTime();
        public static string GetTargetName(Timeline element);
        public static PropertyPath GetTargetProperty(Timeline element);
        public void Pause();
        public void Resume();
        public void Seek(TimeSpan offset);
        public void SeekAlignedToLastTick(TimeSpan offset);
        public static void SetTarget(Timeline timeline, DependencyObject target);
        public static void SetTargetName(Timeline element, string name);
        public static void SetTargetProperty(Timeline element, PropertyPath path);
        public void SkipToFill();
        public void Stop();
    }

    public abstract class Timeline: DependencyObject
    {
        protected Timeline();
        public static readonly DependencyProperty AutoReverseProperty;
        public static readonly DependencyProperty BeginTimeProperty;
        public static readonly DependencyProperty DurationProperty;
        public static readonly DependencyProperty FillBehaviorProperty;
        public static readonly DependencyProperty RepeatBehaviorProperty;
        public static readonly DependencyProperty SpeedRatioProperty;
        public bool AutoReverse { get; set; }
        public Nullable`1<TimeSpan> BeginTime { get; set; }
        public Duration Duration { get; set; }
        public FillBehavior FillBehavior { get; set; }
        public RepeatBehavior RepeatBehavior { get; set; }
        public double SpeedRatio { get; set; }
        public event EventHandler Completed;
    }

    public enum ClockState
    {
        Active,
        Filling,
        Stopped,
    }

    public enum EasingMode
    {
        EaseIn,
        EaseInOut,
        EaseOut,
    }

    public enum FillBehavior
    {
        HoldEnd,
        Stop,
    }

    public enum KeyTimeType
    {
        TimeSpan,
        Uniform,
    }

    [DefaultMemberAttribute(..)]
    public sealed class ColorKeyFrameCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public ColorKeyFrameCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class DoubleKeyFrameCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public DoubleKeyFrameCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class ObjectKeyFrameCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public ObjectKeyFrameCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class PointKeyFrameCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public PointKeyFrameCollection();
    }

    [DefaultMemberAttribute(..)]
    public sealed class TimelineCollection: PresentationFrameworkCollection`1, IList, IList`1
    {
        public TimelineCollection();
    }

} 

namespace System.Windows.Media.Effects
{
    public sealed class BlurEffect: Effect
    {
        public BlurEffect();
        public static readonly DependencyProperty RadiusProperty;
        public double Radius { get; set; }
    }

    public sealed class DropShadowEffect: Effect
    {
        public DropShadowEffect();
        public static readonly DependencyProperty BlurRadiusProperty;
        public static readonly DependencyProperty ColorProperty;
        public static readonly DependencyProperty DirectionProperty;
        public static readonly DependencyProperty OpacityProperty;
        public static readonly DependencyProperty ShadowDepthProperty;
        public double BlurRadius { get; set; }
        public Color Color { get; set; }
        public double Direction { get; set; }
        public double Opacity { get; set; }
        public double ShadowDepth { get; set; }
    }

    public abstract class Effect: DependencyObject
    {
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        [SecurityCriticalAttribute(..)]
        protected Effect();
        protected virtual GeneralTransform EffectMapping { get; }
        public static Brush ImplicitInput { get; }
    }

    public sealed class PixelShader: DependencyObject
    {
        public PixelShader();
        public static readonly DependencyProperty UriSourceProperty;
        public Uri UriSource { get; set; }
    }

    public abstract class ShaderEffect: Effect
    {
        protected ShaderEffect();
        protected static readonly DependencyProperty PixelShaderProperty;
        protected int DdxUvDdyUvRegisterIndex { get; set; }
        protected double PaddingBottom { get; set; }
        protected double PaddingLeft { get; set; }
        protected double PaddingRight { get; set; }
        protected double PaddingTop { get; set; }
        protected PixelShader PixelShader { get; set; }
        protected static PropertyChangedCallback PixelShaderConstantCallback(int register);
        protected static PropertyChangedCallback PixelShaderSamplerCallback(int register);
        protected static PropertyChangedCallback PixelShaderSamplerCallback(int register, SamplingMode samplingMode);
        protected static DependencyProperty RegisterPixelShaderSamplerProperty(string dpName, Type ownerType, int samplerRegisterIndex);
        protected static DependencyProperty RegisterPixelShaderSamplerProperty(string dpName, Type ownerType, int samplerRegisterIndex, SamplingMode samplingMode);
        protected void UpdateShaderValue(DependencyProperty dp);
    }

    public enum SamplingMode
    {
        Auto,
        Bilinear,
        NearestNeighbor,
    }

} 

namespace System.Windows.Media.Imaging
{
    [TypeConverterAttribute(..)]
    public sealed class BitmapImage: BitmapSource
    {
        public BitmapImage();
        public BitmapImage(Uri uriSource);
        public static readonly DependencyProperty CreateOptionsProperty;
        public static readonly DependencyProperty UriSourceProperty;
        public BitmapCreateOptions CreateOptions { get; set; }
        public Uri UriSource { get; set; }
        public event EventHandler`1<DownloadProgressEventArgs> DownloadProgress;
        public event EventHandler`1<ExceptionRoutedEventArgs> ImageFailed;
        public event EventHandler`1<RoutedEventArgs> ImageOpened;
    }

    [TypeConverterAttribute(..)]
    public abstract class BitmapSource: ImageSource
    {
        protected BitmapSource();
        public static readonly DependencyProperty PixelHeightProperty;
        public static readonly DependencyProperty PixelWidthProperty;
        public int PixelHeight { get; }
        public int PixelWidth { get; }
        public void SetSource(Stream streamSource);
    }

    [TypeConverterAttribute(..)]
    public sealed class WriteableBitmap: BitmapSource
    {
        public WriteableBitmap(BitmapSource source);
        public WriteableBitmap(int pixelWidth, int pixelHeight);
        public WriteableBitmap(UIElement element, Transform transform);
        public int[] Pixels { get; }
        protected override void Finalize();
        public void Invalidate();
        public void Render(UIElement element, Transform transform);
    }

    [FlagsAttribute(..)]
    public enum BitmapCreateOptions
    {
        DelayCreation,
        IgnoreImageCache,
        None,
    }

    public sealed class DownloadProgressEventArgs: EventArgs
    {
        public int Progress { get; }
    }

} 

namespace System.Windows.Media.Media3D
{
    public struct Matrix3D: IFormattable
    {
        public Matrix3D(double m11, double m12, double m13, double m14, double m21, double m22, double m23, double m24, double m31, double m32, double m33, double m34, double offsetX, double offsetY, double offsetZ, double m44);
        public bool HasInverse { get; }
        public static Matrix3D Identity { get; }
        public bool IsIdentity { get; }
        public double M11 { get; set; }
        public double M12 { get; set; }
        public double M13 { get; set; }
        public double M14 { get; set; }
        public double M21 { get; set; }
        public double M22 { get; set; }
        public double M23 { get; set; }
        public double M24 { get; set; }
        public double M31 { get; set; }
        public double M32 { get; set; }
        public double M33 { get; set; }
        public double M34 { get; set; }
        public double M44 { get; set; }
        public double OffsetX { get; set; }
        public double OffsetY { get; set; }
        public double OffsetZ { get; set; }
        public bool Equals(Matrix3D value);
        public override bool Equals(object o);
        public override int GetHashCode();
        public void Invert();
        public override string ToString();
        public string ToString(IFormatProvider provider);
        public static Matrix3D operator *(Matrix3D matrix1, Matrix3D matrix2);
        public static bool operator ==(Matrix3D matrix1, Matrix3D matrix2);
        public static bool operator !=(Matrix3D matrix1, Matrix3D matrix2);
    }

} 

namespace System.Windows.Messaging
{
    public sealed class LocalMessageReceiver: IDisposable
    {
        public LocalMessageReceiver(string receiverName);
        public LocalMessageReceiver(string receiverName, ReceiverNameScope nameScope, IEnumerable`1<string> allowedSenderDomains);
        public static readonly IEnumerable`1<string> AnyDomain;
        public IEnumerable`1<string> AllowedSenderDomains { get; }
        public bool DisableSenderTrustCheck { get; set; }
        public ReceiverNameScope NameScope { get; }
        public string ReceiverName { get; }
        public void Dispose();
        public void Listen();
        public event EventHandler`1<MessageReceivedEventArgs> MessageReceived;
    }

    public sealed class LocalMessageSender
    {
        public LocalMessageSender(string receiverName);
        public LocalMessageSender(string receiverName, string receiverDomain);
        public const string Global;
        public string ReceiverDomain { get; }
        public string ReceiverName { get; }
        public void SendAsync(string message);
        public void SendAsync(string message, object userState);
        public event EventHandler`1<SendCompletedEventArgs> SendCompleted;
    }

    public enum ReceiverNameScope
    {
        Domain,
        Global,
    }

    public sealed class MessageReceivedEventArgs: EventArgs
    {
        public string Message { get; }
        public ReceiverNameScope NameScope { get; }
        public string ReceiverName { get; }
        public string Response { get; set; }
        public string SenderDomain { get; }
    }

    public sealed class SendCompletedEventArgs: AsyncCompletedEventArgs
    {
        public string Message { get; }
        public string ReceiverDomain { get; }
        public string ReceiverName { get; }
        public string Response { get; }
    }

    public sealed class ListenFailedException: Exception, _Exception, ISerializable
    {
    }

    public sealed class SendFailedException: Exception, _Exception, ISerializable
    {
    }

} 

namespace System.Windows.Printing
{
    public sealed class PrintDocument: DependencyObject
    {
        public PrintDocument();
        public static readonly DependencyProperty DocumentNameProperty;
        public string DocumentName { get; set; }
        public void Print();
        public event EventHandler`1<EndPrintEventArgs> EndPrint;
        public event EventHandler`1<PrintPageEventArgs> PrintPage;
        public event EventHandler`1<StartPrintEventArgs> StartPrint;
    }

    public sealed class EndPrintEventArgs: EventArgs
    {
        public EndPrintEventArgs();
        public Exception Error { get; }
    }

    public delegate void EndPrintEventHandler(object sender, EndPrintEventArgs e);

    public sealed class PrintPageEventArgs: EventArgs
    {
        public PrintPageEventArgs();
        public bool HasMorePages { get; set; }
        public UIElement PageVisual { get; set; }
        public Size PrintableArea { get; set; }
    }

    public delegate void PrintPageEventHandler(object sender, PrintPageEventArgs e);

    public sealed class StartPrintEventArgs: EventArgs
    {
        public StartPrintEventArgs();
    }

    public delegate void StartPrintEventHandler(object sender, StartPrintEventArgs e);

} 

namespace System.Windows.Resources
{
    public class StreamResourceInfo
    {
        public StreamResourceInfo(Stream stream, string contentType);
        public string ContentType { get; }
        public Stream Stream { get; }
    }

} 

namespace System.Windows.Shapes
{
    public sealed class Ellipse: Shape
    {
        public Ellipse();
    }

    public sealed class Line: Shape
    {
        public Line();
        public static readonly DependencyProperty X1Property;
        public static readonly DependencyProperty X2Property;
        public static readonly DependencyProperty Y1Property;
        public static readonly DependencyProperty Y2Property;
        public double X1 { get; set; }
        public double X2 { get; set; }
        public double Y1 { get; set; }
        public double Y2 { get; set; }
    }

    public class Path: Shape
    {
        public Path();
        public static readonly DependencyProperty DataProperty;
        public Geometry Data { get; set; }
    }

    public sealed class Polygon: Shape
    {
        public Polygon();
        public static readonly DependencyProperty FillRuleProperty;
        public static readonly DependencyProperty PointsProperty;
        public FillRule FillRule { get; set; }
        public PointCollection Points { get; set; }
    }

    public sealed class Polyline: Shape
    {
        public Polyline();
        public static readonly DependencyProperty FillRuleProperty;
        public static readonly DependencyProperty PointsProperty;
        public FillRule FillRule { get; set; }
        public PointCollection Points { get; set; }
    }

    public sealed class Rectangle: Shape
    {
        public Rectangle();
        public static readonly DependencyProperty RadiusXProperty;
        public static readonly DependencyProperty RadiusYProperty;
        public double RadiusX { get; set; }
        public double RadiusY { get; set; }
    }

    public abstract class Shape: FrameworkElement
    {
        protected Shape();
        public static readonly DependencyProperty FillProperty;
        public static readonly DependencyProperty StretchProperty;
        public static readonly DependencyProperty StrokeDashArrayProperty;
        public static readonly DependencyProperty StrokeDashCapProperty;
        public static readonly DependencyProperty StrokeDashOffsetProperty;
        public static readonly DependencyProperty StrokeEndLineCapProperty;
        public static readonly DependencyProperty StrokeLineJoinProperty;
        public static readonly DependencyProperty StrokeMiterLimitProperty;
        public static readonly DependencyProperty StrokeProperty;
        public static readonly DependencyProperty StrokeStartLineCapProperty;
        public static readonly DependencyProperty StrokeThicknessProperty;
        public Brush Fill { get; set; }
        public virtual Transform GeometryTransform { get; }
        public Stretch Stretch { get; set; }
        public Brush Stroke { get; set; }
        public DoubleCollection StrokeDashArray { get; set; }
        public PenLineCap StrokeDashCap { get; set; }
        public double StrokeDashOffset { get; set; }
        public PenLineCap StrokeEndLineCap { get; set; }
        public PenLineJoin StrokeLineJoin { get; set; }
        public double StrokeMiterLimit { get; set; }
        public PenLineCap StrokeStartLineCap { get; set; }
        public double StrokeThickness { get; set; }
    }

} 

namespace System.Windows.Threading
{
    [CLSCompliantAttribute(..)]
    public sealed class Dispatcher
    {
        public DispatcherOperation BeginInvoke(Action a);
        public DispatcherOperation BeginInvoke(Delegate d, params object[] args);
        public bool CheckAccess();
    }

    [CLSCompliantAttribute(..)]
    public sealed class DispatcherOperation
    {
    }

    public sealed class DispatcherSynchronizationContext: SynchronizationContext
    {
        public DispatcherSynchronizationContext();
        public DispatcherSynchronizationContext(Dispatcher dispatcher);
        public override SynchronizationContext CreateCopy();
        public override void Post(SendOrPostCallback d, object state);
        public override void Send(SendOrPostCallback d, object state);
    }

    public class DispatcherTimer
    {
        public DispatcherTimer();
        public TimeSpan Interval { get; set; }
        public bool IsEnabled { get; }
        public void Start();
        public void Stop();
        public event EventHandler Tick;
    }

} 

namespace System.Xml
{
    public interface IXmlLineInfo
    {
        public int LineNumber { get; }
        public int LinePosition { get; }
        public bool HasLineInfo();
    }

    public interface IXmlNamespaceResolver
    {
        public IDictionary`2<string,string> GetNamespacesInScope(XmlNamespaceScope scope);
        public string LookupNamespace(string prefix);
        public string LookupPrefix(string namespaceName);
    }

    public class NameTable: XmlNameTable
    {
        public NameTable();
        public override string Add(char[] key, int start, int len);
        public override string Add(string key);
        public override string Get(char[] key, int start, int len);
        public override string Get(string value);
    }

    public class XmlConvert
    {
        public XmlConvert();
        public static string DecodeName(string name);
        public static string EncodeLocalName(string name);
        public static string EncodeName(string name);
        public static string EncodeNmToken(string name);
        public static bool IsNCNameChar(char ch);
        public static bool IsPublicIdChar(char ch);
        public static bool IsStartNCNameChar(char ch);
        public static bool IsWhitespaceChar(char ch);
        public static bool IsXmlChar(char ch);
        public static bool IsXmlSurrogatePair(char lowChar, char highChar);
        public static bool ToBoolean(string s);
        public static byte ToByte(string s);
        public static char ToChar(string s);
        public static DateTime ToDateTime(string s, string format);
        public static DateTime ToDateTime(string s, string[] formats);
        public static DateTime ToDateTime(string s, XmlDateTimeSerializationMode dateTimeOption);
        public static DateTimeOffset ToDateTimeOffset(string s);
        public static DateTimeOffset ToDateTimeOffset(string s, string format);
        public static DateTimeOffset ToDateTimeOffset(string s, string[] formats);
        public static decimal ToDecimal(string s);
        public static double ToDouble(string s);
        public static Guid ToGuid(string s);
        public static short ToInt16(string s);
        public static int ToInt32(string s);
        public static long ToInt64(string s);
        public static sbyte ToSByte(string s);
        public static float ToSingle(string s);
        public static string ToString(bool value);
        public static string ToString(char value);
        public static string ToString(DateTime value, XmlDateTimeSerializationMode dateTimeOption);
        public static string ToString(DateTimeOffset value);
        public static string ToString(DateTimeOffset value, string format);
        public static string ToString(decimal value);
        public static string ToString(double value);
        public static string ToString(float value);
        public static string ToString(Guid value);
        public static string ToString(int value);
        public static string ToString(long value);
        public static string ToString(sbyte value);
        public static string ToString(short value);
        public static string ToString(TimeSpan value);
        public static string ToString(uint value);
        public static string ToString(ulong value);
        public static TimeSpan ToTimeSpan(string s);
        public static ushort ToUInt16(string s);
        public static uint ToUInt32(string s);
        public static ulong ToUInt64(string s);
        public static string VerifyName(string name);
        public static string VerifyNCName(string name);
        public static string VerifyNMTOKEN(string name);
        public static string VerifyPublicId(string publicId);
        public static string VerifyWhitespace(string content);
        public static string VerifyXmlChars(string content);
    }

    public abstract class XmlNameTable
    {
        protected XmlNameTable();
        public abstract string Add(char[] array, int offset, int length);
        public abstract string Add(string array);
        public abstract string Get(char[] array, int offset, int length);
        public abstract string Get(string array);
    }

    public class XmlParserContext
    {
        public XmlParserContext(XmlNameTable nt, XmlNamespaceManager nsMgr, string docTypeName, string pubId, string sysId, string internalSubset, string baseURI, string xmlLang, XmlSpace xmlSpace);
        public XmlParserContext(XmlNameTable nt, XmlNamespaceManager nsMgr, string docTypeName, string pubId, string sysId, string internalSubset, string baseURI, string xmlLang, XmlSpace xmlSpace, Encoding enc);
        public XmlParserContext(XmlNameTable nt, XmlNamespaceManager nsMgr, string xmlLang, XmlSpace xmlSpace);
        public XmlParserContext(XmlNameTable nt, XmlNamespaceManager nsMgr, string xmlLang, XmlSpace xmlSpace, Encoding enc);
        public string BaseURI { get; set; }
        public string DocTypeName { get; set; }
        public Encoding Encoding { get; set; }
        public string InternalSubset { get; set; }
        public XmlNamespaceManager NamespaceManager { get; set; }
        public XmlNameTable NameTable { get; set; }
        public string PublicId { get; set; }
        public string SystemId { get; set; }
        public string XmlLang { get; set; }
        public XmlSpace XmlSpace { get; set; }
    }

    public class XmlQualifiedName
    {
        public XmlQualifiedName();
        public XmlQualifiedName(string name);
        public XmlQualifiedName(string name, string ns);
        public static readonly XmlQualifiedName Empty;
        public bool IsEmpty { get; }
        public string Name { get; }
        public string Namespace { get; }
        public override bool Equals(object other);
        public override int GetHashCode();
        public override string ToString();
        public static string ToString(string name, string ns);
        public static bool operator ==(XmlQualifiedName a, XmlQualifiedName b);
        public static bool operator !=(XmlQualifiedName a, XmlQualifiedName b);
    }

    [DefaultMemberAttribute(..)]
    public abstract class XmlReader: IDisposable
    {
        protected XmlReader();
        public abstract int AttributeCount { get; }
        public abstract string BaseURI { get; }
        public virtual bool CanReadBinaryContent { get; }
        public virtual bool CanReadValueChunk { get; }
        public virtual bool CanResolveEntity { get; }
        public abstract int Depth { get; }
        public abstract bool EOF { get; }
        public virtual bool HasAttributes { get; }
        public virtual bool HasValue { get; }
        public virtual bool IsDefault { get; }
        public abstract bool IsEmptyElement { get; }
        public abstract string LocalName { get; }
        public virtual string Name { get; }
        public abstract string NamespaceURI { get; }
        public abstract XmlNameTable NameTable { get; }
        public abstract XmlNodeType NodeType { get; }
        public abstract string Prefix { get; }
        public abstract ReadState ReadState { get; }
        public virtual XmlReaderSettings Settings { get; }
        public abstract string Value { get; }
        public virtual Type ValueType { get; }
        public virtual string XmlLang { get; }
        public virtual XmlSpace XmlSpace { get; }
        public virtual string this[int i] { get; }
        public virtual string this[string name] { get; }
        public virtual string this[string name, string namespaceURI] { get; }
        public abstract void Close();
        public static XmlReader Create(Stream input);
        public static XmlReader Create(Stream input, XmlReaderSettings settings);
        public static XmlReader Create(Stream input, XmlReaderSettings settings, string baseUri);
        public static XmlReader Create(Stream input, XmlReaderSettings settings, XmlParserContext inputContext);
        public static XmlReader Create(string inputUri);
        public static XmlReader Create(string inputUri, XmlReaderSettings settings);
        public static XmlReader Create(string inputUri, XmlReaderSettings settings, XmlParserContext inputContext);
        public static XmlReader Create(TextReader input);
        public static XmlReader Create(TextReader input, XmlReaderSettings settings);
        public static XmlReader Create(TextReader input, XmlReaderSettings settings, string baseUri);
        public static XmlReader Create(TextReader input, XmlReaderSettings settings, XmlParserContext inputContext);
        public static XmlReader Create(XmlReader reader, XmlReaderSettings settings);
        protected virtual void Dispose(bool disposing);
        public abstract string GetAttribute(int i);
        public abstract string GetAttribute(string name);
        public abstract string GetAttribute(string name, string namespaceURI);
        public static bool IsName(string str);
        public static bool IsNameToken(string str);
        public virtual bool IsStartElement();
        public virtual bool IsStartElement(string name);
        public virtual bool IsStartElement(string localname, string ns);
        public abstract string LookupNamespace(string prefix);
        public virtual void MoveToAttribute(int i);
        public abstract bool MoveToAttribute(string name);
        public abstract bool MoveToAttribute(string name, string ns);
        public virtual XmlNodeType MoveToContent();
        public abstract bool MoveToElement();
        public abstract bool MoveToFirstAttribute();
        public abstract bool MoveToNextAttribute();
        public abstract bool Read();
        public abstract bool ReadAttributeValue();
        public virtual object ReadContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver);
        public virtual int ReadContentAsBase64(byte[] buffer, int index, int count);
        public virtual int ReadContentAsBinHex(byte[] buffer, int index, int count);
        public virtual bool ReadContentAsBoolean();
        public virtual DateTime ReadContentAsDateTime();
        public virtual decimal ReadContentAsDecimal();
        public virtual double ReadContentAsDouble();
        public virtual float ReadContentAsFloat();
        public virtual int ReadContentAsInt();
        public virtual long ReadContentAsLong();
        public virtual object ReadContentAsObject();
        public virtual string ReadContentAsString();
        public virtual object ReadElementContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver);
        public virtual object ReadElementContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver, string localName, string namespaceURI);
        public virtual int ReadElementContentAsBase64(byte[] buffer, int index, int count);
        public virtual int ReadElementContentAsBinHex(byte[] buffer, int index, int count);
        public virtual bool ReadElementContentAsBoolean();
        public virtual bool ReadElementContentAsBoolean(string localName, string namespaceURI);
        public virtual DateTime ReadElementContentAsDateTime();
        public virtual DateTime ReadElementContentAsDateTime(string localName, string namespaceURI);
        public virtual decimal ReadElementContentAsDecimal();
        public virtual decimal ReadElementContentAsDecimal(string localName, string namespaceURI);
        public virtual double ReadElementContentAsDouble();
        public virtual double ReadElementContentAsDouble(string localName, string namespaceURI);
        public virtual float ReadElementContentAsFloat();
        public virtual float ReadElementContentAsFloat(string localName, string namespaceURI);
        public virtual int ReadElementContentAsInt();
        public virtual int ReadElementContentAsInt(string localName, string namespaceURI);
        public virtual long ReadElementContentAsLong();
        public virtual long ReadElementContentAsLong(string localName, string namespaceURI);
        public virtual object ReadElementContentAsObject();
        public virtual object ReadElementContentAsObject(string localName, string namespaceURI);
        public virtual string ReadElementContentAsString();
        public virtual string ReadElementContentAsString(string localName, string namespaceURI);
        public virtual void ReadEndElement();
        public virtual string ReadInnerXml();
        public virtual string ReadOuterXml();
        public virtual void ReadStartElement();
        public virtual void ReadStartElement(string name);
        public virtual void ReadStartElement(string localname, string ns);
        public virtual XmlReader ReadSubtree();
        public virtual bool ReadToDescendant(string name);
        public virtual bool ReadToDescendant(string localName, string namespaceURI);
        public virtual bool ReadToFollowing(string name);
        public virtual bool ReadToFollowing(string localName, string namespaceURI);
        public virtual bool ReadToNextSibling(string name);
        public virtual bool ReadToNextSibling(string localName, string namespaceURI);
        public virtual int ReadValueChunk(char[] buffer, int index, int count);
        public abstract void ResolveEntity();
        public virtual void Skip();
    }

    public sealed class XmlReaderSettings
    {
        public XmlReaderSettings();
        public bool CheckCharacters { get; set; }
        public bool CloseInput { get; set; }
        public ConformanceLevel ConformanceLevel { get; set; }
        public DtdProcessing DtdProcessing { get; set; }
        public bool IgnoreComments { get; set; }
        public bool IgnoreProcessingInstructions { get; set; }
        public bool IgnoreWhitespace { get; set; }
        public int LineNumberOffset { get; set; }
        public int LinePositionOffset { get; set; }
        public long MaxCharactersFromEntities { get; set; }
        public long MaxCharactersInDocument { get; set; }
        public XmlNameTable NameTable { get; set; }
        public XmlResolver XmlResolver { set; }
        public XmlReaderSettings Clone();
        public void Reset();
    }

    public abstract class XmlResolver
    {
        protected XmlResolver();
        public abstract object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn);
        public virtual Uri ResolveUri(Uri baseUri, string relativeUri);
        public virtual bool SupportsType(Uri absoluteUri, Type type);
    }

    public abstract class XmlWriter: IDisposable
    {
        protected XmlWriter();
        public virtual XmlWriterSettings Settings { get; }
        public abstract WriteState WriteState { get; }
        public virtual string XmlLang { get; }
        public virtual XmlSpace XmlSpace { get; }
        public abstract void Close();
        public static XmlWriter Create(Stream output);
        public static XmlWriter Create(Stream output, XmlWriterSettings settings);
        public static XmlWriter Create(StringBuilder output);
        public static XmlWriter Create(StringBuilder output, XmlWriterSettings settings);
        public static XmlWriter Create(TextWriter output);
        public static XmlWriter Create(TextWriter output, XmlWriterSettings settings);
        public static XmlWriter Create(XmlWriter output);
        public static XmlWriter Create(XmlWriter output, XmlWriterSettings settings);
        protected virtual void Dispose(bool disposing);
        public abstract void Flush();
        public abstract string LookupPrefix(string ns);
        public virtual void WriteAttributes(XmlReader reader, bool defattr);
        public void WriteAttributeString(string localName, string value);
        public void WriteAttributeString(string localName, string ns, string value);
        public void WriteAttributeString(string prefix, string localName, string ns, string value);
        public abstract void WriteBase64(byte[] buffer, int index, int count);
        public virtual void WriteBinHex(byte[] buffer, int index, int count);
        public abstract void WriteCData(string text);
        public abstract void WriteCharEntity(char ch);
        public abstract void WriteChars(char[] buffer, int index, int count);
        public abstract void WriteComment(string text);
        public abstract void WriteDocType(string name, string pubid, string sysid, string subset);
        public void WriteElementString(string localName, string value);
        public void WriteElementString(string localName, string ns, string value);
        public void WriteElementString(string prefix, string localName, string ns, string value);
        public abstract void WriteEndAttribute();
        public abstract void WriteEndDocument();
        public abstract void WriteEndElement();
        public abstract void WriteEntityRef(string name);
        public abstract void WriteFullEndElement();
        public virtual void WriteName(string name);
        public virtual void WriteNmToken(string name);
        public virtual void WriteNode(XmlReader reader, bool defattr);
        public abstract void WriteProcessingInstruction(string name, string text);
        public virtual void WriteQualifiedName(string localName, string ns);
        public abstract void WriteRaw(char[] buffer, int index, int count);
        public abstract void WriteRaw(string data);
        public void WriteStartAttribute(string localName);
        public void WriteStartAttribute(string localName, string ns);
        public abstract void WriteStartAttribute(string prefix, string localName, string ns);
        public abstract void WriteStartDocument();
        public abstract void WriteStartDocument(bool standalone);
        public void WriteStartElement(string localName);
        public void WriteStartElement(string localName, string ns);
        public abstract void WriteStartElement(string prefix, string localName, string ns);
        public abstract void WriteString(string text);
        public abstract void WriteSurrogateCharEntity(char lowChar, char highChar);
        public virtual void WriteValue(bool value);
        public virtual void WriteValue(DateTime value);
        public virtual void WriteValue(decimal value);
        public virtual void WriteValue(double value);
        public virtual void WriteValue(float value);
        public virtual void WriteValue(int value);
        public virtual void WriteValue(long value);
        public virtual void WriteValue(object value);
        public virtual void WriteValue(string value);
        public abstract void WriteWhitespace(string ws);
    }

    public sealed class XmlWriterSettings
    {
        public XmlWriterSettings();
        public bool CheckCharacters { get; set; }
        public bool CloseOutput { get; set; }
        public ConformanceLevel ConformanceLevel { get; set; }
        public Encoding Encoding { get; set; }
        public bool Indent { get; set; }
        public string IndentChars { get; set; }
        public NamespaceHandling NamespaceHandling { get; set; }
        public string NewLineChars { get; set; }
        public NewLineHandling NewLineHandling { get; set; }
        public bool NewLineOnAttributes { get; set; }
        public bool OmitXmlDeclaration { get; set; }
        public XmlWriterSettings Clone();
        public void Reset();
    }

    public class XmlXapResolver: XmlResolver
    {
        public XmlXapResolver();
        public override object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn);
    }

    public enum ConformanceLevel
    {
        Auto,
        Document,
        Fragment,
    }

    public enum DtdProcessing
    {
        Ignore,
        Parse,
        Prohibit,
    }

    [FlagsAttribute(..)]
    public enum NamespaceHandling
    {
        Default,
        OmitDuplicates,
    }

    public enum NewLineHandling
    {
        Entitize,
        None,
        Replace,
    }

    public enum ReadState
    {
        Closed,
        EndOfFile,
        Error,
        Initial,
        Interactive,
    }

    public enum WriteState
    {
        Attribute,
        Closed,
        Content,
        Element,
        Error,
        Prolog,
        Start,
    }

    public enum XmlDateTimeSerializationMode
    {
        Local,
        RoundtripKind,
        Unspecified,
        Utc,
    }

    public enum XmlNamespaceScope
    {
        All,
        ExcludeXml,
        Local,
    }

    public enum XmlNodeType
    {
        Attribute,
        CDATA,
        Comment,
        Document,
        DocumentFragment,
        DocumentType,
        Element,
        EndElement,
        EndEntity,
        Entity,
        EntityReference,
        None,
        Notation,
        ProcessingInstruction,
        SignificantWhitespace,
        Text,
        Whitespace,
        XmlDeclaration,
    }

    public enum XmlSpace
    {
        Default,
        None,
        Preserve,
    }

    public enum XmlTokenizedType
    {
        CDATA,
        ENTITIES,
        ENTITY,
        ENUMERATION,
        ID,
        IDREF,
        IDREFS,
        NCName,
        NMTOKEN,
        NMTOKENS,
        None,
        NOTATION,
        QName,
    }

    public class XmlNamespaceManager: IEnumerable, IXmlNamespaceResolver
    {
        public XmlNamespaceManager(XmlNameTable nameTable);
        public virtual string DefaultNamespace { get; }
        public virtual XmlNameTable NameTable { get; }
        public virtual void AddNamespace(string prefix, string uri);
        public virtual IEnumerator GetEnumerator();
        public virtual IDictionary`2<string,string> GetNamespacesInScope(XmlNamespaceScope scope);
        public virtual bool HasNamespace(string prefix);
        public virtual string LookupNamespace(string prefix);
        public virtual string LookupPrefix(string uri);
        public virtual bool PopScope();
        public virtual void PushScope();
        public virtual void RemoveNamespace(string prefix, string uri);
    }

    public class XmlException: SystemException, _Exception, ISerializable
    {
        public XmlException();
        public XmlException(string message);
        public XmlException(string message, Exception innerException);
        public XmlException(string message, Exception innerException, int lineNumber, int linePosition);
        public int LineNumber { get; }
        public int LinePosition { get; }
        public string SourceUri { get; }
    }

} 

namespace System.Xml.Schema
{
    public class XmlSchema: XmlSchemaObject
    {
    }

    public abstract class XmlSchemaObject
    {
        protected XmlSchemaObject();
    }

    public class XmlSchemaSet
    {
    }

    public enum XmlSchemaForm
    {
        None,
        Qualified,
        Unqualified,
    }

    public enum XmlSeverityType
    {
        Error,
        Warning,
    }

    public enum XmlTypeCode
    {
        AnyAtomicType,
        AnyUri,
        Attribute,
        Base64Binary,
        Boolean,
        Byte,
        Comment,
        Date,
        DateTime,
        DayTimeDuration,
        Decimal,
        Document,
        Double,
        Duration,
        Element,
        Entity,
        Float,
        GDay,
        GMonth,
        GMonthDay,
        GYear,
        GYearMonth,
        HexBinary,
        Id,
        Idref,
        Int,
        Integer,
        Item,
        Language,
        Long,
        Name,
        Namespace,
        NCName,
        NegativeInteger,
        NmToken,
        Node,
        None,
        NonNegativeInteger,
        NonPositiveInteger,
        NormalizedString,
        Notation,
        PositiveInteger,
        ProcessingInstruction,
        QName,
        Short,
        String,
        Text,
        Time,
        Token,
        UnsignedByte,
        UnsignedInt,
        UnsignedLong,
        UnsignedShort,
        UntypedAtomic,
        YearMonthDuration,
    }

} 

namespace System.Xml.Serialization
{
    public interface IXmlSerializable
    {
        public XmlSchema GetSchema();
        public void ReadXml(XmlReader reader);
        public void WriteXml(XmlWriter writer);
    }

    [AttributeUsageAttribute(..)]
    public class XmlAnyElementAttribute: Attribute, _Attribute
    {
        public XmlAnyElementAttribute();
        public XmlAnyElementAttribute(string name);
        public XmlAnyElementAttribute(string name, string ns);
        public string Name { get; set; }
        public string Namespace { get; set; }
        public int Order { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlArrayAttribute: Attribute, _Attribute
    {
        public XmlArrayAttribute();
        public XmlArrayAttribute(string elementName);
        public string ElementName { get; set; }
        public XmlSchemaForm Form { get; set; }
        public bool IsNullable { get; set; }
        public string Namespace { get; set; }
        public int Order { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlArrayItemAttribute: Attribute, _Attribute
    {
        public XmlArrayItemAttribute();
        public XmlArrayItemAttribute(string elementName);
        public XmlArrayItemAttribute(string elementName, Type type);
        public XmlArrayItemAttribute(Type type);
        public string DataType { get; set; }
        public string ElementName { get; set; }
        public XmlSchemaForm Form { get; set; }
        public bool IsNullable { get; set; }
        public string Namespace { get; set; }
        public int NestingLevel { get; set; }
        public Type Type { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlAttributeAttribute: Attribute, _Attribute
    {
        public XmlAttributeAttribute();
        public XmlAttributeAttribute(string attributeName);
        public XmlAttributeAttribute(string attributeName, Type type);
        public XmlAttributeAttribute(Type type);
        public string AttributeName { get; set; }
        public string DataType { get; set; }
        public XmlSchemaForm Form { get; set; }
        public string Namespace { get; set; }
        public Type Type { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlChoiceIdentifierAttribute: Attribute, _Attribute
    {
        public XmlChoiceIdentifierAttribute();
        public XmlChoiceIdentifierAttribute(string name);
        public string MemberName { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlElementAttribute: Attribute, _Attribute
    {
        public XmlElementAttribute();
        public XmlElementAttribute(string elementName);
        public XmlElementAttribute(string elementName, Type type);
        public XmlElementAttribute(Type type);
        public string DataType { get; set; }
        public string ElementName { get; set; }
        public XmlSchemaForm Form { get; set; }
        public bool IsNullable { get; set; }
        public string Namespace { get; set; }
        public int Order { get; set; }
        public Type Type { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlEnumAttribute: Attribute, _Attribute
    {
        public XmlEnumAttribute();
        public XmlEnumAttribute(string name);
        public string Name { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlIgnoreAttribute: Attribute, _Attribute
    {
        public XmlIgnoreAttribute();
    }

    [AttributeUsageAttribute(..)]
    public class XmlIncludeAttribute: Attribute, _Attribute
    {
        public XmlIncludeAttribute(Type type);
        public Type Type { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlNamespaceDeclarationsAttribute: Attribute, _Attribute
    {
        public XmlNamespaceDeclarationsAttribute();
    }

    [AttributeUsageAttribute(..)]
    public class XmlRootAttribute: Attribute, _Attribute
    {
        public XmlRootAttribute();
        public XmlRootAttribute(string elementName);
        public string DataType { get; set; }
        public string ElementName { get; set; }
        public bool IsNullable { get; set; }
        public string Namespace { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class XmlSchemaProviderAttribute: Attribute, _Attribute
    {
        public XmlSchemaProviderAttribute(string methodName);
        public bool IsAny { get; set; }
        public string MethodName { get; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlTextAttribute: Attribute, _Attribute
    {
        public XmlTextAttribute();
        public XmlTextAttribute(Type type);
        public string DataType { get; set; }
        public Type Type { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class XmlTypeAttribute: Attribute, _Attribute
    {
        public XmlTypeAttribute();
        public XmlTypeAttribute(string typeName);
        public bool AnonymousType { get; set; }
        public bool IncludeInSchema { get; set; }
        public string Namespace { get; set; }
        public string TypeName { get; set; }
    }

} 

namespace System.ComponentModel.DataAnnotations
{
    public sealed class ValidationContext: IServiceProvider
    {
        public ValidationContext(object instance, IServiceProvider serviceProvider, IDictionary`2<object,object> items);
        public string DisplayName { get; set; }
        public IDictionary`2<object,object> Items { get; }
        public string MemberName { get; set; }
        public object ObjectInstance { get; }
        public Type ObjectType { get; }
        public object GetService(Type serviceType);
    }

    public sealed class ValidationResult
    {
        public ValidationResult(string errorMessage);
        public ValidationResult(string errorMessage, IEnumerable`1<string> memberNames);
        public static readonly ValidationResult Success;
        public string ErrorMessage { get; set; }
        public IEnumerable`1<string> MemberNames { get; }
        public override string ToString();
    }

    public abstract sealed class Validator
    {
        public static bool TryValidateObject(object instance, ValidationContext validationContext, ICollection`1<ValidationResult> validationResults);
        public static bool TryValidateObject(object instance, ValidationContext validationContext, ICollection`1<ValidationResult> validationResults, bool validateAllProperties);
        public static bool TryValidateProperty(object value, ValidationContext validationContext, ICollection`1<ValidationResult> validationResults);
        public static bool TryValidateValue(object value, ValidationContext validationContext, ICollection`1<ValidationResult> validationResults, IEnumerable`1<ValidationAttribute> validationAttributes);
        public static void ValidateObject(object instance, ValidationContext validationContext);
        public static void ValidateObject(object instance, ValidationContext validationContext, bool validateAllProperties);
        public static void ValidateProperty(object value, ValidationContext validationContext);
        public static void ValidateValue(object value, ValidationContext validationContext, IEnumerable`1<ValidationAttribute> validationAttributes);
    }

    public enum DataType
    {
        Currency,
        Custom,
        Date,
        DateTime,
        Duration,
        EmailAddress,
        Html,
        ImageUrl,
        MultilineText,
        Password,
        PhoneNumber,
        Text,
        Time,
        Url,
    }

    [AttributeUsageAttribute(..)]
    public sealed class AssociationAttribute: Attribute, _Attribute
    {
        public AssociationAttribute(string name, string thisKey, string otherKey);
        public bool IsForeignKey { get; set; }
        public string Name { get; }
        public string OtherKey { get; }
        public IEnumerable`1<string> OtherKeyMembers { get; }
        public string ThisKey { get; }
        public IEnumerable`1<string> ThisKeyMembers { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class ConcurrencyCheckAttribute: Attribute, _Attribute
    {
        public ConcurrencyCheckAttribute();
    }

    [AttributeUsageAttribute(..)]
    public sealed class CustomValidationAttribute: ValidationAttribute, _Attribute
    {
        public CustomValidationAttribute(Type validatorType, string method);
        public string Method { get; }
        public Type ValidatorType { get; }
        public override string FormatErrorMessage(string name);
        protected override ValidationResult IsValid(object value, ValidationContext validationContext);
    }

    [AttributeUsageAttribute(..)]
    public class DataTypeAttribute: ValidationAttribute, _Attribute
    {
        public DataTypeAttribute(DataType dataType);
        public DataTypeAttribute(string customDataType);
        public string CustomDataType { get; set; }
        public DataType DataType { get; set; }
        public DisplayFormatAttribute DisplayFormat { get; set; }
        public virtual string GetDataTypeName();
    }

    [AttributeUsageAttribute(..)]
    public sealed class DisplayAttribute: Attribute, _Attribute
    {
        public DisplayAttribute();
        public bool AutoGenerateField { get; set; }
        public bool AutoGenerateFilter { get; set; }
        public string Description { get; set; }
        public string GroupName { get; set; }
        public string Name { get; set; }
        public int Order { get; set; }
        public string Prompt { get; set; }
        public Type ResourceType { get; set; }
        public string ShortName { get; set; }
        public Nullable`1<bool> GetAutoGenerateField();
        public Nullable`1<bool> GetAutoGenerateFilter();
        public string GetDescription();
        public string GetGroupName();
        public string GetName();
        public Nullable`1<int> GetOrder();
        public string GetPrompt();
        public string GetShortName();
    }

    [AttributeUsageAttribute(..)]
    public class DisplayColumnAttribute: Attribute, _Attribute
    {
        public DisplayColumnAttribute(string displayColumn);
        public DisplayColumnAttribute(string displayColumn, string sortColumn);
        public DisplayColumnAttribute(string displayColumn, string sortColumn, bool sortDescending);
        public string DisplayColumn { get; set; }
        public string SortColumn { get; set; }
        public bool SortDescending { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class DisplayFormatAttribute: Attribute, _Attribute
    {
        public DisplayFormatAttribute();
        public bool ApplyFormatInEditMode { get; set; }
        public bool ConvertEmptyStringToNull { get; set; }
        public string DataFormatString { get; set; }
        public string NullDisplayText { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class EditableAttribute: Attribute, _Attribute
    {
        public EditableAttribute(bool allowEdit);
        public bool AllowEdit { get; set; }
        public bool AllowInitialValue { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class EnumDataTypeAttribute: DataTypeAttribute, _Attribute
    {
        public EnumDataTypeAttribute(Type enumType);
        public Type EnumType { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class FilterUIHintAttribute: Attribute, _Attribute
    {
        public FilterUIHintAttribute(string filterUIHint);
        public FilterUIHintAttribute(string filterUIHint, string presentationLayer);
        public FilterUIHintAttribute(string filterUIHint, string presentationLayer, params object[] controlParameters);
        public IDictionary`2<string,object> ControlParameters { get; }
        public string FilterUIHint { get; }
        public string PresentationLayer { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
    }

    [AttributeUsageAttribute(..)]
    public sealed class KeyAttribute: Attribute, _Attribute
    {
        public KeyAttribute();
    }

    [AttributeUsageAttribute(..)]
    public class RangeAttribute: ValidationAttribute, _Attribute
    {
        public RangeAttribute(double minimum, double maximum);
        public RangeAttribute(int minimum, int maximum);
        public RangeAttribute(Type type, string minimum, string maximum);
        public object Maximum { get; set; }
        public object Minimum { get; set; }
        public Type OperandType { get; set; }
        public override string FormatErrorMessage(string name);
    }

    [AttributeUsageAttribute(..)]
    public class RegularExpressionAttribute: ValidationAttribute, _Attribute
    {
        public RegularExpressionAttribute(string pattern);
        public string Pattern { get; set; }
        public override string FormatErrorMessage(string name);
    }

    [AttributeUsageAttribute(..)]
    public class RequiredAttribute: ValidationAttribute, _Attribute
    {
        public RequiredAttribute();
        public bool AllowEmptyStrings { get; set; }
    }

    [AttributeUsageAttribute(..)]
    public class StringLengthAttribute: ValidationAttribute, _Attribute
    {
        public StringLengthAttribute(int maximumLength);
        public int MaximumLength { get; set; }
        public int MinimumLength { get; set; }
        public override string FormatErrorMessage(string name);
    }

    [AttributeUsageAttribute(..)]
    public sealed class TimestampAttribute: Attribute, _Attribute
    {
        public TimestampAttribute();
    }

    [AttributeUsageAttribute(..)]
    public class UIHintAttribute: Attribute, _Attribute
    {
        public UIHintAttribute(string uiHint);
        public UIHintAttribute(string uiHint, string presentationLayer);
        public UIHintAttribute(string uiHint, string presentationLayer, params object[] controlParameters);
        public IDictionary`2<string,object> ControlParameters { get; }
        public string PresentationLayer { get; }
        public string UIHint { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
    }

    [AttributeUsageAttribute(..)]
    public abstract class ValidationAttribute: Attribute, _Attribute
    {
        protected ValidationAttribute();
        protected ValidationAttribute(Func`1<string> errorMessageAccessor);
        protected ValidationAttribute(string errorMessage);
        public string ErrorMessage { get; set; }
        public string ErrorMessageResourceName { get; set; }
        public Type ErrorMessageResourceType { get; set; }
        protected string ErrorMessageString { get; }
        public virtual string FormatErrorMessage(string name);
        public ValidationResult GetValidationResult(object value, ValidationContext validationContext);
        protected virtual ValidationResult IsValid(object value, ValidationContext validationContext);
        public void Validate(object value, ValidationContext validationContext);
    }

    public class ValidationException: Exception, _Exception, ISerializable
    {
        public ValidationException();
        public ValidationException(string message);
        public ValidationException(string message, Exception innerException);
        public ValidationException(string errorMessage, ValidationAttribute validatingAttribute, object value);
        public ValidationException(ValidationResult validationResult, ValidationAttribute validatingAttribute, object value);
        public ValidationAttribute ValidationAttribute { get; set; }
        public ValidationResult ValidationResult { get; }
        public object Value { get; set; }
    }

} 

namespace System.ComponentModel
{
    public interface IPagedCollectionView
    {
        public bool CanChangePage { get; }
        public bool IsPageChanging { get; }
        public int ItemCount { get; }
        public int PageIndex { get; }
        public int PageSize { get; set; }
        public int TotalItemCount { get; }
        public bool MoveToFirstPage();
        public bool MoveToLastPage();
        public bool MoveToNextPage();
        public bool MoveToPage(int pageIndex);
        public bool MoveToPreviousPage();
        public event EventHandler`1<EventArgs> PageChanged;
        public event EventHandler`1<PageChangingEventArgs> PageChanging;
    }

    public sealed class PageChangingEventArgs: CancelEventArgs
    {
        public PageChangingEventArgs(int newPageIndex);
        public int NewPageIndex { get; set; }
    }

} 

namespace System.Windows.Data
{
    [DefaultMemberAttribute(..)]
    public sealed class PagedCollectionView: ICollectionView, IEditableCollectionView, INotifyPropertyChanged, IPagedCollectionView
    {
        public PagedCollectionView(IEnumerable source);
        public PagedCollectionView(IEnumerable source, bool isDataSorted, bool isDataInGroupOrder);
        public bool CanAddNew { get; }
        public bool CanCancelEdit { get; }
        public bool CanChangePage { get; }
        public bool CanFilter { get; }
        public bool CanGroup { get; }
        public bool CanRemove { get; }
        public bool CanSort { get; }
        public int Count { get; }
        public CultureInfo Culture { get; set; }
        public object CurrentAddItem { get; set; }
        public object CurrentEditItem { get; set; }
        public object CurrentItem { get; }
        public int CurrentPosition { get; }
        public Predicate`1<object> Filter { get; set; }
        public ObservableCollection`1<GroupDescription> GroupDescriptions { get; }
        public ReadOnlyObservableCollection`1<object> Groups { get; }
        public bool IsAddingNew { get; }
        public bool IsCurrentAfterLast { get; }
        public bool IsCurrentBeforeFirst { get; }
        public bool IsEditingItem { get; }
        public bool IsEmpty { get; }
        public bool IsPageChanging { get; set; }
        public int ItemCount { get; }
        public bool NeedsRefresh { get; }
        public NewItemPlaceholderPosition NewItemPlaceholderPosition { get; set; }
        public int PageIndex { get; }
        public int PageSize { get; set; }
        public SortDescriptionCollection SortDescriptions { get; }
        public IEnumerable SourceCollection { get; }
        public int TotalItemCount { get; }
        public object this[int index] { get; }
        public object AddNew();
        public void CancelEdit();
        public void CancelNew();
        public void CommitEdit();
        public void CommitNew();
        public bool Contains(object item);
        public IDisposable DeferRefresh();
        public void EditItem(object item);
        public IEnumerator GetEnumerator();
        public object GetItemAt(int index);
        public int IndexOf(object item);
        public bool MoveCurrentTo(object item);
        public bool MoveCurrentToFirst();
        public bool MoveCurrentToLast();
        public bool MoveCurrentToNext();
        public bool MoveCurrentToPosition(int position);
        public bool MoveCurrentToPrevious();
        public bool MoveToFirstPage();
        public bool MoveToLastPage();
        public bool MoveToNextPage();
        public bool MoveToPage(int pageIndex);
        public bool MoveToPreviousPage();
        public bool PassesFilter(object item);
        public void Refresh();
        public void Remove(object item);
        public void RemoveAt(int index);
        public event NotifyCollectionChangedEventHandler CollectionChanged;
        public event EventHandler CurrentChanged;
        public event CurrentChangingEventHandler CurrentChanging;
        public event EventHandler`1<EventArgs> PageChanged;
        public event EventHandler`1<PageChangingEventArgs> PageChanging;
        public event PropertyChangedEventHandler PropertyChanged;
    }

    public delegate GroupDescription GroupDescriptionSelectorCallback(CollectionViewGroup group, int level);

} 

namespace System.Data.Services.Client
{
    public sealed class ChangeOperationResponse: OperationResponse
    {
        public Descriptor Descriptor { get; }
    }

    public class DataServiceContext
    {
        public DataServiceContext(Uri serviceRoot);
        public bool ApplyingChanges { get; set; }
        public Uri BaseUri { get; }
        public string DataNamespace { get; set; }
        public ReadOnlyCollection`1<EntityDescriptor> Entities { get; }
        public HttpStack HttpStack { get; set; }
        public bool IgnoreMissingProperties { get; set; }
        public bool IgnoreResourceNotFoundException { get; set; }
        public ReadOnlyCollection`1<LinkDescriptor> Links { get; }
        public MergeOption MergeOption { get; set; }
        public Func`2<Type,string> ResolveName { get; set; }
        public Func`2<string,Type> ResolveType { get; set; }
        public SaveChangesOptions SaveChangesDefaultOptions { get; set; }
        public Uri TypeScheme { get; set; }
        public bool UsePostTunneling { get; set; }
        public void AddLink(object source, string sourceProperty, object target);
        public void AddObject(string entitySetName, object entity);
        public void AddRelatedObject(object source, string sourceProperty, object target);
        public void AttachLink(object source, string sourceProperty, object target);
        public void AttachTo(string entitySetName, object entity);
        public void AttachTo(string entitySetName, object entity, string etag);
        public IAsyncResult BeginExecute<T>(DataServiceQueryContinuation`1<T> continuation, AsyncCallback callback, object state);
        public IAsyncResult BeginExecute<TElement>(Uri requestUri, AsyncCallback callback, object state);
        public IAsyncResult BeginExecuteBatch(AsyncCallback callback, object state, params DataServiceRequest[] queries);
        public IAsyncResult BeginGetReadStream(object entity, DataServiceRequestArgs args, AsyncCallback callback, object state);
        public IAsyncResult BeginLoadProperty(object entity, string propertyName, AsyncCallback callback, object state);
        public IAsyncResult BeginLoadProperty(object entity, string propertyName, DataServiceQueryContinuation continuation, AsyncCallback callback, object state);
        public IAsyncResult BeginLoadProperty(object entity, string propertyName, Uri nextLinkUri, AsyncCallback callback, object state);
        public IAsyncResult BeginSaveChanges(AsyncCallback callback, object state);
        public IAsyncResult BeginSaveChanges(SaveChangesOptions options, AsyncCallback callback, object state);
        public void CancelRequest(IAsyncResult asyncResult);
        public DataServiceQuery`1<T> CreateQuery<T>(string entitySetName);
        public void DeleteLink(object source, string sourceProperty, object target);
        public void DeleteObject(object entity);
        public bool Detach(object entity);
        public bool DetachLink(object source, string sourceProperty, object target);
        public IEnumerable`1<TElement> EndExecute<TElement>(IAsyncResult asyncResult);
        public DataServiceResponse EndExecuteBatch(IAsyncResult asyncResult);
        public DataServiceStreamResponse EndGetReadStream(IAsyncResult asyncResult);
        public QueryOperationResponse EndLoadProperty(IAsyncResult asyncResult);
        public DataServiceResponse EndSaveChanges(IAsyncResult asyncResult);
        public EntityDescriptor GetEntityDescriptor(object entity);
        public LinkDescriptor GetLinkDescriptor(object source, string sourceProperty, object target);
        public Uri GetMetadataUri();
        public Uri GetReadStreamUri(object entity);
        public void SetLink(object source, string sourceProperty, object target);
        public void SetSaveStream(object entity, Stream stream, bool closeStream, DataServiceRequestArgs args);
        public void SetSaveStream(object entity, Stream stream, bool closeStream, string contentType, string slug);
        public bool TryGetEntity<TEntity>(Uri identity, ref TEntity entity);
        public bool TryGetUri(object entity, ref Uri identity);
        public void UpdateObject(object entity);
        public event EventHandler`1<ReadingWritingEntityEventArgs> ReadingEntity;
        public event EventHandler`1<SendingRequestEventArgs> SendingRequest;
        public event EventHandler`1<ReadingWritingEntityEventArgs> WritingEntity;
    }

    [DebuggerDisplayAttribute(..)]
    public abstract class DataServiceQueryContinuation
    {
        public Uri NextLinkUri { get; }
        public override string ToString();
    }

    [DebuggerDisplayAttribute(..)]
    public sealed class DataServiceQueryContinuation`1<T>: DataServiceQueryContinuation
    {
    }

    public abstract class DataServiceRequest
    {
        public abstract Type ElementType { get; }
        public abstract Uri RequestUri { get; }
        public override string ToString();
    }

    public sealed class DataServiceRequest`1<TElement>: DataServiceRequest
    {
        public DataServiceRequest`1(Uri requestUri);
    }

    public class DataServiceRequestArgs
    {
        public DataServiceRequestArgs();
        public string AcceptContentType { get; set; }
        public string ContentType { get; set; }
        public Dictionary`2<string,string> Headers { get; }
        public string Slug { get; set; }
    }

    public sealed class DataServiceStreamResponse: IDisposable
    {
        public string ContentDisposition { get; }
        public string ContentType { get; }
        public Dictionary`2<string,string> Headers { get; }
        public Stream Stream { get; }
        public void Dispose();
    }

    public abstract class Descriptor
    {
        public EntityStates State { get; set; }
    }

    public sealed class EntityChangedParams
    {
        public DataServiceContext Context { get; }
        public object Entity { get; }
        public string PropertyName { get; }
        public object PropertyValue { get; }
        public string SourceEntitySet { get; }
        public string TargetEntitySet { get; }
    }

    public sealed class EntityCollectionChangedParams
    {
        public NotifyCollectionChangedAction Action { get; }
        public ICollection Collection { get; }
        public DataServiceContext Context { get; }
        public string PropertyName { get; }
        public object SourceEntity { get; }
        public string SourceEntitySet { get; }
        public object TargetEntity { get; }
        public string TargetEntitySet { get; }
    }

    [DebuggerDisplayAttribute(..)]
    public sealed class EntityDescriptor: Descriptor
    {
        public Uri EditLink { get; set; }
        public Uri EditStreamUri { get; set; }
        public object Entity { get; }
        public string ETag { get; set; }
        public string Identity { get; set; }
        public EntityDescriptor ParentForInsert { get; }
        public string ParentPropertyForInsert { get; }
        public Uri ReadStreamUri { get; set; }
        public Uri SelfLink { get; set; }
        public string ServerTypeName { get; set; }
        public string StreamETag { get; set; }
    }

    [DebuggerDisplayAttribute(..)]
    public sealed class LinkDescriptor: Descriptor
    {
        public object Source { get; }
        public string SourceProperty { get; }
        public object Target { get; }
    }

    public abstract class OperationResponse
    {
        public Exception Error { get; set; }
        public IDictionary`2<string,string> Headers { get; }
        public int StatusCode { get; set; }
    }

    [FlagsAttribute(..)]
    public enum EntityStates
    {
        Added,
        Deleted,
        Detached,
        Modified,
        Unchanged,
    }

    public enum HttpStack
    {
        Auto,
        ClientHttp,
        XmlHttp,
    }

    public enum MergeOption
    {
        AppendOnly,
        NoTracking,
        OverwriteChanges,
        PreserveChanges,
    }

    [FlagsAttribute(..)]
    public enum SaveChangesOptions
    {
        Batch,
        ContinueOnError,
        None,
        ReplaceOnUpdate,
    }

    public enum TrackingMode
    {
        AutoChangeTracking,
        None,
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public class DataServiceCollection`1<T>: ObservableCollection`1, IList, IList`1<T>, INotifyCollectionChanged, INotifyPropertyChanged
    {
        public DataServiceCollection`1();
        public DataServiceCollection`1(DataServiceContext context);
        public DataServiceCollection`1(DataServiceContext context, IEnumerable`1<T> items, TrackingMode trackingMode, string entitySetName, Func`2<EntityChangedParams,bool> entityChangedCallback, Func`2<EntityCollectionChangedParams,bool> collectionChangedCallback);
        public DataServiceCollection`1(DataServiceContext context, string entitySetName, Func`2<EntityChangedParams,bool> entityChangedCallback, Func`2<EntityCollectionChangedParams,bool> collectionChangedCallback);
        public DataServiceCollection`1(IEnumerable`1<T> items);
        public DataServiceCollection`1(IEnumerable`1<T> items, TrackingMode trackingMode);
        public DataServiceCollection`1(IEnumerable`1<T> items, TrackingMode trackingMode, string entitySetName, Func`2<EntityChangedParams,bool> entityChangedCallback, Func`2<EntityCollectionChangedParams,bool> collectionChangedCallback);
        public DataServiceQueryContinuation`1<T> Continuation { get; set; }
        public void Clear(bool stopTracking);
        protected override void ClearItems();
        public void Detach();
        protected override void InsertItem(int index, T item);
        public void Load(IEnumerable`1<T> items);
        public void Load(T item);
        public void LoadAsync();
        public void LoadAsync(IQueryable`1<T> query);
        public bool LoadNextPartialSetAsync();
        public event EventHandler`1<LoadCompletedEventArgs> LoadCompleted;
    }

    public abstract class DataServiceQuery: DataServiceRequest, IQueryable
    {
        public abstract Expression Expression { get; }
        public abstract IQueryProvider Provider { get; }
        public IAsyncResult BeginExecute(AsyncCallback callback, object state);
        public IEnumerable EndExecute(IAsyncResult asyncResult);
    }

    public class DataServiceQuery`1<TElement>: DataServiceQuery, IQueryable`1<TElement>
    {
        public DataServiceQuery`1<TElement> AddQueryOption(string name, object value);
        public IAsyncResult BeginExecute(AsyncCallback callback, object state);
        public IEnumerable`1<TElement> EndExecute(IAsyncResult asyncResult);
        public DataServiceQuery`1<TElement> Expand(string path);
        public DataServiceQuery`1<TElement> IncludeTotalCount();
        public override string ToString();
    }

    public sealed class DataServiceResponse: IEnumerable`1
    {
        public IDictionary`2<string,string> BatchHeaders { get; }
        public int BatchStatusCode { get; }
        public bool IsBatchResponse { get; }
        public IEnumerator`1<OperationResponse> GetEnumerator();
    }

    public class QueryOperationResponse: OperationResponse, IEnumerable
    {
        public DataServiceRequest Query { get; }
        public virtual long TotalCount { get; }
        public DataServiceQueryContinuation GetContinuation();
        public DataServiceQueryContinuation GetContinuation(IEnumerable collection);
        public DataServiceQueryContinuation`1<T> GetContinuation<T>(IEnumerable`1<T> collection);
        public IEnumerator GetEnumerator();
    }

    public sealed class QueryOperationResponse`1<T>: QueryOperationResponse, IEnumerable`1<T>
    {
        public DataServiceQueryContinuation`1<T> GetContinuation();
        public IEnumerator`1<T> GetEnumerator();
    }

    public sealed class LoadCompletedEventArgs: AsyncCompletedEventArgs
    {
        public QueryOperationResponse QueryOperationResponse { get; }
    }

    public sealed class ReadingWritingEntityEventArgs: EventArgs
    {
        public XElement Data { get; }
        public object Entity { get; }
    }

    public class SendingRequestEventArgs: EventArgs
    {
        public WebHeaderCollection RequestHeaders { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class MediaEntryAttribute: Attribute, _Attribute
    {
        public MediaEntryAttribute(string mediaMemberName);
        public string MediaMemberName { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class MimeTypePropertyAttribute: Attribute, _Attribute
    {
        public MimeTypePropertyAttribute(string dataPropertyName, string mimeTypePropertyName);
        public string DataPropertyName { get; }
        public string MimeTypePropertyName { get; }
    }

    [DebuggerDisplayAttribute(..)]
    public sealed class DataServiceClientException: InvalidOperationException, _Exception, ISerializable
    {
        public DataServiceClientException();
        public DataServiceClientException(string message);
        public DataServiceClientException(string message, Exception innerException);
        public DataServiceClientException(string message, Exception innerException, int statusCode);
        public DataServiceClientException(string message, int statusCode);
        public int StatusCode { get; }
    }

    [DebuggerDisplayAttribute(..)]
    public sealed class DataServiceQueryException: InvalidOperationException, _Exception, ISerializable
    {
        public DataServiceQueryException();
        public DataServiceQueryException(string message);
        public DataServiceQueryException(string message, Exception innerException);
        public DataServiceQueryException(string message, Exception innerException, QueryOperationResponse response);
        public QueryOperationResponse Response { get; }
    }

    [DebuggerDisplayAttribute(..)]
    public sealed class DataServiceRequestException: InvalidOperationException, _Exception, ISerializable
    {
        public DataServiceRequestException();
        public DataServiceRequestException(string message);
        public DataServiceRequestException(string message, Exception innerException);
        public DataServiceRequestException(string message, Exception innerException, DataServiceResponse response);
        public DataServiceResponse Response { get; }
    }

} 

namespace System.Data.Services.Common
{
    public enum SyndicationItemProperty
    {
        AuthorEmail,
        AuthorName,
        AuthorUri,
        ContributorEmail,
        ContributorName,
        ContributorUri,
        CustomProperty,
        Published,
        Rights,
        Summary,
        Title,
        Updated,
    }

    public enum SyndicationTextContentKind
    {
        Html,
        Plaintext,
        Xhtml,
    }

    [AttributeUsageAttribute(..)]
    public sealed class DataServiceEntityAttribute: Attribute, _Attribute
    {
        public DataServiceEntityAttribute();
    }

    [AttributeUsageAttribute(..)]
    public sealed class DataServiceKeyAttribute: Attribute, _Attribute
    {
        public DataServiceKeyAttribute(string keyName);
        public DataServiceKeyAttribute(params string[] keyNames);
        public ReadOnlyCollection`1<string> KeyNames { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class EntityPropertyMappingAttribute: Attribute, _Attribute
    {
        public EntityPropertyMappingAttribute(string sourcePath, string targetPath, string targetNamespacePrefix, string targetNamespaceUri, bool keepInContent);
        public EntityPropertyMappingAttribute(string sourcePath, SyndicationItemProperty targetSyndicationItem, SyndicationTextContentKind targetTextContentKind, bool keepInContent);
        public bool KeepInContent { get; }
        public string SourcePath { get; }
        public string TargetNamespacePrefix { get; }
        public string TargetNamespaceUri { get; }
        public string TargetPath { get; }
        public SyndicationItemProperty TargetSyndicationItem { get; }
        public SyndicationTextContentKind TargetTextContentKind { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class EntitySetAttribute: Attribute, _Attribute
    {
        public EntitySetAttribute(string entitySet);
        public string EntitySet { get; }
    }

    [AttributeUsageAttribute(..)]
    public sealed class HasStreamAttribute: Attribute, _Attribute
    {
        public HasStreamAttribute();
    }

} 

namespace System.Json
{
    public enum JsonType
    {
        Array,
        Boolean,
        Number,
        Object,
        String,
    }

    [DefaultMemberAttribute(..)]
    public class JsonArray: JsonValue, IList`1
    {
        public JsonArray(IEnumerable`1<JsonValue> items);
        public JsonArray(params JsonValue[] items);
        public bool IsReadOnly { get; }
        public void Add(JsonValue item);
        public void AddRange(IEnumerable`1<JsonValue> items);
        public void AddRange(params JsonValue[] items);
        public void Clear();
        public bool Contains(JsonValue item);
        public void CopyTo(JsonValue[] array, int arrayIndex);
        public int IndexOf(JsonValue item);
        public void Insert(int index, JsonValue item);
        public bool Remove(JsonValue item);
        public void RemoveAt(int index);
        public override void Save(Stream stream);
    }

    [DefaultMemberAttribute(..)]
    public class JsonObject: JsonValue, IDictionary`2
    {
        public JsonObject(DateTimeOffset dto);
        public JsonObject(IEnumerable`1<KeyValuePair`2<string,JsonValue>> items);
        public JsonObject(params KeyValuePair`2<string,JsonValue>[] items);
        public ICollection`1<string> Keys { get; }
        public ICollection`1<JsonValue> Values { get; }
        public void Add(KeyValuePair`2<string,JsonValue> item);
        public void Add(string key, JsonValue value);
        public void AddRange(IEnumerable`1<KeyValuePair`2<string,JsonValue>> items);
        public void AddRange(params KeyValuePair`2<string,JsonValue>[] items);
        public void Clear();
        public override bool ContainsKey(string key);
        public void CopyTo(KeyValuePair`2<string,JsonValue>[] array, int arrayIndex);
        public IEnumerator`1<KeyValuePair`2<string,JsonValue>> GetEnumerator();
        public bool Remove(string key);
        public override void Save(Stream stream);
        public bool TryGetValue(string key, ref JsonValue value);
    }

    [DefaultMemberAttribute(..)]
    public class JsonPrimitive: JsonValue, IEnumerable
    {
        public JsonPrimitive(bool value);
        public JsonPrimitive(byte value);
        public JsonPrimitive(char value);
        public JsonPrimitive(DateTime value);
        public JsonPrimitive(decimal value);
        public JsonPrimitive(double value);
        public JsonPrimitive(float value);
        public JsonPrimitive(Guid value);
        public JsonPrimitive(int value);
        public JsonPrimitive(long value);
        public JsonPrimitive(sbyte value);
        public JsonPrimitive(short value);
        public JsonPrimitive(string value);
        public JsonPrimitive(TimeSpan value);
        public JsonPrimitive(uint value);
        public JsonPrimitive(ulong value);
        public JsonPrimitive(Uri value);
        public JsonPrimitive(ushort value);
        public override void Save(Stream stream);
    }

    [DefaultMemberAttribute(..)]
    public abstract class JsonValue: IEnumerable
    {
        public virtual int Count { get; }
        public abstract JsonType JsonType { get; }
        public virtual JsonValue this[int index] { get; set; }
        public virtual JsonValue this[string key] { get; set; }
        public virtual bool ContainsKey(string key);
        public static JsonValue Load(Stream stream);
        public static JsonValue Load(TextReader textReader);
        public static JsonValue Parse(string jsonString);
        public abstract void Save(Stream stream);
        public virtual void Save(TextWriter textWriter);
        public override string ToString();
        public static implicit operator bool(JsonValue value);
        public static implicit operator byte(JsonValue value);
        public static implicit operator char(JsonValue value);
        public static implicit operator DateTime(JsonValue value);
        public static implicit operator DateTimeOffset(JsonValue value);
        public static implicit operator decimal(JsonValue value);
        public static implicit operator double(JsonValue value);
        public static implicit operator float(JsonValue value);
        public static implicit operator Guid(JsonValue value);
        public static implicit operator int(JsonValue value);
        public static implicit operator JsonValue(bool value);
        public static implicit operator JsonValue(byte value);
        public static implicit operator JsonValue(char value);
        public static implicit operator JsonValue(DateTime value);
        public static implicit operator JsonValue(DateTimeOffset value);
        public static implicit operator JsonValue(decimal value);
        public static implicit operator JsonValue(double value);
        public static implicit operator JsonValue(float value);
        public static implicit operator JsonValue(Guid value);
        public static implicit operator JsonValue(int value);
        public static implicit operator JsonValue(long value);
        public static implicit operator JsonValue(sbyte value);
        public static implicit operator JsonValue(short value);
        public static implicit operator JsonValue(string value);
        public static implicit operator JsonValue(TimeSpan value);
        public static implicit operator JsonValue(uint value);
        public static implicit operator JsonValue(ulong value);
        public static implicit operator JsonValue(Uri value);
        public static implicit operator JsonValue(ushort value);
        public static implicit operator long(JsonValue value);
        public static implicit operator sbyte(JsonValue value);
        public static implicit operator short(JsonValue value);
        public static implicit operator string(JsonValue value);
        public static implicit operator TimeSpan(JsonValue value);
        public static implicit operator uint(JsonValue value);
        public static implicit operator ulong(JsonValue value);
        public static implicit operator Uri(JsonValue value);
        public static implicit operator ushort(JsonValue value);
    }

} 

namespace System.Runtime.Serialization.Json
{
    public abstract sealed class JsonReaderWriterFactory
    {
        public static XmlDictionaryReader CreateJsonReader(byte[] buffer, int offset, int count, XmlDictionaryReaderQuotas quotas);
        public static XmlDictionaryReader CreateJsonReader(byte[] buffer, XmlDictionaryReaderQuotas quotas);
        public static XmlDictionaryReader CreateJsonReader(Stream stream, XmlDictionaryReaderQuotas quotas);
        public static XmlDictionaryWriter CreateJsonWriter(Stream stream);
        public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding);
        public static XmlDictionaryWriter CreateJsonWriter(Stream stream, Encoding encoding, bool ownsStream);
    }

} 

namespace System.ServiceModel
{
    public class PollingDuplexHttpBinding: Binding, IDefaultCommunicationTimeouts
    {
        public PollingDuplexHttpBinding();
        public PollingDuplexHttpBinding(PollingDuplexHttpSecurityMode securityMode);
        public EnvelopeVersion EnvelopeVersion { get; }
        public TimeSpan InactivityTimeout { get; set; }
        public int MaxBufferSize { get; set; }
        public long MaxReceivedMessageSize { get; set; }
        public PollingDuplexHttpSecurity Security { get; }
        public Encoding TextEncoding { get; set; }
        public bool UseTextEncoding { get; set; }
        public override BindingElementCollection CreateBindingElements();
    }

    public sealed class PollingDuplexHttpSecurity
    {
        public PollingDuplexHttpSecurityMode Mode { get; set; }
    }

    public enum PollingDuplexHttpSecurityMode
    {
        None,
        Transport,
        TransportCredentialOnly,
        TransportWithMessageCredential,
    }

} 

namespace System.ServiceModel.Channels
{
    public class PollingDuplexBindingElement: BindingElement
    {
        public PollingDuplexBindingElement();
        protected PollingDuplexBindingElement(PollingDuplexBindingElement elementToBeCloned);
        public TimeSpan ClientPollTimeout { get; set; }
        public TimeSpan InactivityTimeout { get; set; }
        public override IChannelFactory`1<TChannel> BuildChannelFactory<TChannel>(BindingContext context);
        public override bool CanBuildChannelFactory<TChannel>(BindingContext context);
        public override BindingElement Clone();
        public override T GetProperty<T>(BindingContext context);
    }

} 

namespace System.ServiceModel.Syndication
{
    [XmlRootAttribute(..)]
    public class Atom10FeedFormatter: SyndicationFeedFormatter, IXmlSerializable
    {
        public Atom10FeedFormatter();
        public Atom10FeedFormatter(SyndicationFeed feedToWrite);
        public Atom10FeedFormatter(Type feedTypeToCreate);
        protected Type FeedType { get; }
        public bool PreserveAttributeExtensions { get; set; }
        public bool PreserveElementExtensions { get; set; }
        public override bool CanRead(XmlReader reader);
        protected override SyndicationFeed CreateFeedInstance();
        public override void ReadFrom(XmlReader reader);
        protected virtual SyndicationItem ReadItem(XmlReader reader, SyndicationFeed feed);
        protected virtual IEnumerable`1<SyndicationItem> ReadItems(XmlReader reader, SyndicationFeed feed, ref bool areAllItemsRead);
        protected virtual void WriteItem(XmlWriter writer, SyndicationItem item, Uri feedBaseUri);
        protected virtual void WriteItems(XmlWriter writer, IEnumerable`1<SyndicationItem> items, Uri feedBaseUri);
        public override void WriteTo(XmlWriter writer);
    }

    [XmlRootAttribute(..)]
    public class Atom10FeedFormatter`1<TSyndicationFeed>: Atom10FeedFormatter, IXmlSerializable where TSyndicationFeed:SyndicationFeed,IExtensibleSyndicationObject
    {
        public Atom10FeedFormatter`1();
        public Atom10FeedFormatter`1(TSyndicationFeed feedToWrite);
        protected override SyndicationFeed CreateFeedInstance();
    }

    [XmlRootAttribute(..)]
    public class Atom10ItemFormatter: SyndicationItemFormatter, IXmlSerializable
    {
        public Atom10ItemFormatter();
        public Atom10ItemFormatter(SyndicationItem itemToWrite);
        public Atom10ItemFormatter(Type itemTypeToCreate);
        protected Type ItemType { get; }
        public bool PreserveAttributeExtensions { get; set; }
        public bool PreserveElementExtensions { get; set; }
        public override bool CanRead(XmlReader reader);
        protected override SyndicationItem CreateItemInstance();
        public override void ReadFrom(XmlReader reader);
        public override void WriteTo(XmlWriter writer);
    }

    [XmlRootAttribute(..)]
    public class Atom10ItemFormatter`1<TSyndicationItem>: Atom10ItemFormatter, IXmlSerializable where TSyndicationItem:SyndicationItem,IExtensibleSyndicationObject
    {
        public Atom10ItemFormatter`1();
        public Atom10ItemFormatter`1(TSyndicationItem itemToWrite);
        protected override SyndicationItem CreateItemInstance();
    }

    [XmlRootAttribute(..)]
    public class Rss20FeedFormatter: SyndicationFeedFormatter, IXmlSerializable
    {
        public Rss20FeedFormatter();
        public Rss20FeedFormatter(SyndicationFeed feedToWrite);
        public Rss20FeedFormatter(SyndicationFeed feedToWrite, bool serializeExtensionsAsAtom);
        public Rss20FeedFormatter(Type feedTypeToCreate);
        protected Type FeedType { get; }
        public bool PreserveAttributeExtensions { get; set; }
        public bool PreserveElementExtensions { get; set; }
        public bool SerializeExtensionsAsAtom { get; set; }
        public override bool CanRead(XmlReader reader);
        protected override SyndicationFeed CreateFeedInstance();
        public override void ReadFrom(XmlReader reader);
        protected virtual SyndicationItem ReadItem(XmlReader reader, SyndicationFeed feed);
        protected virtual IEnumerable`1<SyndicationItem> ReadItems(XmlReader reader, SyndicationFeed feed, ref bool areAllItemsRead);
        protected override void SetFeed(SyndicationFeed feed);
        protected virtual void WriteItem(XmlWriter writer, SyndicationItem item, Uri feedBaseUri);
        protected virtual void WriteItems(XmlWriter writer, IEnumerable`1<SyndicationItem> items, Uri feedBaseUri);
        public override void WriteTo(XmlWriter writer);
    }

    [XmlRootAttribute(..)]
    public class Rss20FeedFormatter`1<TSyndicationFeed>: Rss20FeedFormatter, IXmlSerializable where TSyndicationFeed:SyndicationFeed,IExtensibleSyndicationObject
    {
        public Rss20FeedFormatter`1();
        public Rss20FeedFormatter`1(TSyndicationFeed feedToWrite);
        public Rss20FeedFormatter`1(TSyndicationFeed feedToWrite, bool serializeExtensionsAsAtom);
        protected override SyndicationFeed CreateFeedInstance();
    }

    [XmlRootAttribute(..)]
    public class Rss20ItemFormatter: SyndicationItemFormatter, IXmlSerializable
    {
        public Rss20ItemFormatter();
        public Rss20ItemFormatter(SyndicationItem itemToWrite);
        public Rss20ItemFormatter(SyndicationItem itemToWrite, bool serializeExtensionsAsAtom);
        public Rss20ItemFormatter(Type itemTypeToCreate);
        protected Type ItemType { get; }
        public bool PreserveAttributeExtensions { get; set; }
        public bool PreserveElementExtensions { get; set; }
        public bool SerializeExtensionsAsAtom { get; set; }
        public override bool CanRead(XmlReader reader);
        protected override SyndicationItem CreateItemInstance();
        public override void ReadFrom(XmlReader reader);
        public override void WriteTo(XmlWriter writer);
    }

    [XmlRootAttribute(..)]
    public class Rss20ItemFormatter`1<TSyndicationItem>: Rss20ItemFormatter, IXmlSerializable where TSyndicationItem:SyndicationItem,IExtensibleSyndicationObject
    {
        public Rss20ItemFormatter`1();
        public Rss20ItemFormatter`1(TSyndicationItem itemToWrite);
        public Rss20ItemFormatter`1(TSyndicationItem itemToWrite, bool serializeExtensionsAsAtom);
        protected override SyndicationItem CreateItemInstance();
    }

    public class SyndicationCategory
    {
        public SyndicationCategory();
        public SyndicationCategory(string name);
        public SyndicationCategory(string name, string scheme, string label);
        protected SyndicationCategory(SyndicationCategory source);
        public Dictionary`2<XmlQualifiedName,string> AttributeExtensions { get; }
        public SyndicationElementExtensionCollection ElementExtensions { get; }
        public string Label { get; set; }
        public string Name { get; set; }
        public string Scheme { get; set; }
        public virtual SyndicationCategory Clone();
        protected virtual bool TryParseAttribute(string name, string ns, string value, string version);
        protected virtual bool TryParseElement(XmlReader reader, string version);
        protected virtual void WriteAttributeExtensions(XmlWriter writer, string version);
        protected virtual void WriteElementExtensions(XmlWriter writer, string version);
    }

    public abstract class SyndicationContent
    {
        protected SyndicationContent();
        protected SyndicationContent(SyndicationContent source);
        public Dictionary`2<XmlQualifiedName,string> AttributeExtensions { get; }
        public abstract string Type { get; }
        public abstract SyndicationContent Clone();
        public static TextSyndicationContent CreateHtmlContent(string content);
        public static TextSyndicationContent CreatePlaintextContent(string content);
        public static UrlSyndicationContent CreateUrlContent(Uri url, string mediaType);
        public static TextSyndicationContent CreateXhtmlContent(string content);
        public static XmlSyndicationContent CreateXmlContent(object dataContractObject);
        public static XmlSyndicationContent CreateXmlContent(object dataContractObject, XmlObjectSerializer dataContractSerializer);
        public static XmlSyndicationContent CreateXmlContent(object xmlSerializerObject, XmlSerializer serializer);
        public static XmlSyndicationContent CreateXmlContent(XmlReader xmlReader);
        protected abstract void WriteContentsTo(XmlWriter writer);
        public void WriteTo(XmlWriter writer, string outerElementName, string outerElementNamespace);
    }

    public class SyndicationElementExtension
    {
        public SyndicationElementExtension(object dataContractExtension);
        public SyndicationElementExtension(object dataContractExtension, XmlObjectSerializer dataContractSerializer);
        public SyndicationElementExtension(object xmlSerializerExtension, XmlSerializer serializer);
        public SyndicationElementExtension(string outerName, string outerNamespace, object dataContractExtension);
        public SyndicationElementExtension(string outerName, string outerNamespace, object dataContractExtension, XmlObjectSerializer dataContractSerializer);
        public SyndicationElementExtension(XmlReader xmlReader);
        public string OuterName { get; }
        public string OuterNamespace { get; }
        public TExtension GetObject<TExtension>();
        public TExtension GetObject<TExtension>(XmlObjectSerializer serializer);
        public TExtension GetObject<TExtension>(XmlSerializer serializer);
        public XmlReader GetReader();
        public void WriteTo(XmlWriter writer);
    }

    public class SyndicationFeed
    {
        public SyndicationFeed();
        public SyndicationFeed(IEnumerable`1<SyndicationItem> items);
        public SyndicationFeed(string title, string description, Uri feedAlternateLink);
        public SyndicationFeed(string title, string description, Uri feedAlternateLink, IEnumerable`1<SyndicationItem> items);
        public SyndicationFeed(string title, string description, Uri feedAlternateLink, string id, DateTimeOffset lastUpdatedTime);
        public SyndicationFeed(string title, string description, Uri feedAlternateLink, string id, DateTimeOffset lastUpdatedTime, IEnumerable`1<SyndicationItem> items);
        protected SyndicationFeed(SyndicationFeed source, bool cloneItems);
        public Dictionary`2<XmlQualifiedName,string> AttributeExtensions { get; }
        public Collection`1<SyndicationPerson> Authors { get; }
        public Uri BaseUri { get; set; }
        public Collection`1<SyndicationCategory> Categories { get; }
        public Collection`1<SyndicationPerson> Contributors { get; }
        public TextSyndicationContent Copyright { get; set; }
        public TextSyndicationContent Description { get; set; }
        public SyndicationElementExtensionCollection ElementExtensions { get; }
        public string Generator { get; set; }
        public string Id { get; set; }
        public Uri ImageUrl { get; set; }
        public IEnumerable`1<SyndicationItem> Items { get; set; }
        public string Language { get; set; }
        public DateTimeOffset LastUpdatedTime { get; set; }
        public Collection`1<SyndicationLink> Links { get; }
        public TextSyndicationContent Title { get; set; }
        public virtual SyndicationFeed Clone(bool cloneItems);
        protected virtual SyndicationCategory CreateCategory();
        protected virtual SyndicationItem CreateItem();
        protected virtual SyndicationLink CreateLink();
        protected virtual SyndicationPerson CreatePerson();
        public Atom10FeedFormatter GetAtom10Formatter();
        public Rss20FeedFormatter GetRss20Formatter();
        public Rss20FeedFormatter GetRss20Formatter(bool serializeExtensionsAsAtom);
        public static SyndicationFeed Load(XmlReader reader);
        public static TSyndicationFeed Load<TSyndicationFeed>(XmlReader reader);
        public void SaveAsAtom10(XmlWriter writer);
        public void SaveAsRss20(XmlWriter writer);
        protected virtual bool TryParseAttribute(string name, string ns, string value, string version);
        protected virtual bool TryParseElement(XmlReader reader, string version);
        protected virtual void WriteAttributeExtensions(XmlWriter writer, string version);
        protected virtual void WriteElementExtensions(XmlWriter writer, string version);
    }

    [DataContractAttribute(..)]
    public abstract class SyndicationFeedFormatter
    {
        protected SyndicationFeedFormatter();
        protected SyndicationFeedFormatter(SyndicationFeed feedToWrite);
        public SyndicationFeed Feed { get; }
        public abstract string Version { get; }
        public abstract bool CanRead(XmlReader reader);
        protected static SyndicationCategory CreateCategory(SyndicationFeed feed);
        protected static SyndicationCategory CreateCategory(SyndicationItem item);
        protected abstract SyndicationFeed CreateFeedInstance();
        protected static SyndicationItem CreateItem(SyndicationFeed feed);
        protected static SyndicationLink CreateLink(SyndicationFeed feed);
        protected static SyndicationLink CreateLink(SyndicationItem item);
        protected static SyndicationPerson CreatePerson(SyndicationFeed feed);
        protected static SyndicationPerson CreatePerson(SyndicationItem item);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationCategory category, int maxExtensionSize);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationFeed feed, int maxExtensionSize);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationItem item, int maxExtensionSize);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationLink link, int maxExtensionSize);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationPerson person, int maxExtensionSize);
        public abstract void ReadFrom(XmlReader reader);
        protected virtual void SetFeed(SyndicationFeed feed);
        public override string ToString();
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationCategory category, string version);
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationFeed feed, string version);
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationItem item, string version);
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationLink link, string version);
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationPerson person, string version);
        protected static bool TryParseContent(XmlReader reader, SyndicationItem item, string contentType, string version, ref SyndicationContent content);
        protected static bool TryParseElement(XmlReader reader, SyndicationCategory category, string version);
        protected static bool TryParseElement(XmlReader reader, SyndicationFeed feed, string version);
        protected static bool TryParseElement(XmlReader reader, SyndicationItem item, string version);
        protected static bool TryParseElement(XmlReader reader, SyndicationLink link, string version);
        protected static bool TryParseElement(XmlReader reader, SyndicationPerson person, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationCategory category, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationFeed feed, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationItem item, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationLink link, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationPerson person, string version);
        protected static void WriteElementExtensions(XmlWriter writer, SyndicationCategory category, string version);
        protected static void WriteElementExtensions(XmlWriter writer, SyndicationFeed feed, string version);
        protected static void WriteElementExtensions(XmlWriter writer, SyndicationItem item, string version);
        protected static void WriteElementExtensions(XmlWriter writer, SyndicationLink link, string version);
        protected static void WriteElementExtensions(XmlWriter writer, SyndicationPerson person, string version);
        public abstract void WriteTo(XmlWriter writer);
    }

    public class SyndicationItem
    {
        public SyndicationItem();
        public SyndicationItem(string title, string content, Uri itemAlternateLink);
        public SyndicationItem(string title, string content, Uri itemAlternateLink, string id, DateTimeOffset lastUpdatedTime);
        public SyndicationItem(string title, SyndicationContent content, Uri itemAlternateLink, string id, DateTimeOffset lastUpdatedTime);
        protected SyndicationItem(SyndicationItem source);
        public Dictionary`2<XmlQualifiedName,string> AttributeExtensions { get; }
        public Collection`1<SyndicationPerson> Authors { get; }
        public Uri BaseUri { get; set; }
        public Collection`1<SyndicationCategory> Categories { get; }
        public SyndicationContent Content { get; set; }
        public Collection`1<SyndicationPerson> Contributors { get; }
        public TextSyndicationContent Copyright { get; set; }
        public SyndicationElementExtensionCollection ElementExtensions { get; }
        public string Id { get; set; }
        public DateTimeOffset LastUpdatedTime { get; set; }
        public Collection`1<SyndicationLink> Links { get; }
        public DateTimeOffset PublishDate { get; set; }
        public SyndicationFeed SourceFeed { get; set; }
        public TextSyndicationContent Summary { get; set; }
        public TextSyndicationContent Title { get; set; }
        public void AddPermalink(Uri permalink);
        public virtual SyndicationItem Clone();
        protected virtual SyndicationCategory CreateCategory();
        protected virtual SyndicationLink CreateLink();
        protected virtual SyndicationPerson CreatePerson();
        public Atom10ItemFormatter GetAtom10Formatter();
        public Rss20ItemFormatter GetRss20Formatter();
        public Rss20ItemFormatter GetRss20Formatter(bool serializeExtensionsAsAtom);
        public static SyndicationItem Load(XmlReader reader);
        public static TSyndicationItem Load<TSyndicationItem>(XmlReader reader);
        public void SaveAsAtom10(XmlWriter writer);
        public void SaveAsRss20(XmlWriter writer);
        protected virtual bool TryParseAttribute(string name, string ns, string value, string version);
        protected virtual bool TryParseContent(XmlReader reader, string contentType, string version, ref SyndicationContent content);
        protected virtual bool TryParseElement(XmlReader reader, string version);
        protected virtual void WriteAttributeExtensions(XmlWriter writer, string version);
        protected virtual void WriteElementExtensions(XmlWriter writer, string version);
    }

    [DataContractAttribute(..)]
    public abstract class SyndicationItemFormatter
    {
        protected SyndicationItemFormatter();
        protected SyndicationItemFormatter(SyndicationItem itemToWrite);
        public SyndicationItem Item { get; }
        public abstract string Version { get; }
        public abstract bool CanRead(XmlReader reader);
        protected static SyndicationCategory CreateCategory(SyndicationItem item);
        protected abstract SyndicationItem CreateItemInstance();
        protected static SyndicationLink CreateLink(SyndicationItem item);
        protected static SyndicationPerson CreatePerson(SyndicationItem item);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationCategory category, int maxExtensionSize);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationItem item, int maxExtensionSize);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationLink link, int maxExtensionSize);
        protected static void LoadElementExtensions(XmlReader reader, SyndicationPerson person, int maxExtensionSize);
        public abstract void ReadFrom(XmlReader reader);
        protected virtual void SetItem(SyndicationItem item);
        public override string ToString();
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationCategory category, string version);
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationItem item, string version);
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationLink link, string version);
        protected static bool TryParseAttribute(string name, string ns, string value, SyndicationPerson person, string version);
        protected static bool TryParseContent(XmlReader reader, SyndicationItem item, string contentType, string version, ref SyndicationContent content);
        protected static bool TryParseElement(XmlReader reader, SyndicationCategory category, string version);
        protected static bool TryParseElement(XmlReader reader, SyndicationItem item, string version);
        protected static bool TryParseElement(XmlReader reader, SyndicationLink link, string version);
        protected static bool TryParseElement(XmlReader reader, SyndicationPerson person, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationCategory category, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationItem item, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationLink link, string version);
        protected static void WriteAttributeExtensions(XmlWriter writer, SyndicationPerson person, string version);
        protected void WriteElementExtensions(XmlWriter writer, SyndicationCategory category, string version);
        protected static void WriteElementExtensions(XmlWriter writer, SyndicationItem item, string version);
        protected void WriteElementExtensions(XmlWriter writer, SyndicationLink link, string version);
        protected void WriteElementExtensions(XmlWriter writer, SyndicationPerson person, string version);
        public abstract void WriteTo(XmlWriter writer);
    }

    public class SyndicationLink
    {
        public SyndicationLink();
        protected SyndicationLink(SyndicationLink source);
        public SyndicationLink(Uri uri);
        public SyndicationLink(Uri uri, string relationshipType, string title, string mediaType, long length);
        public Dictionary`2<XmlQualifiedName,string> AttributeExtensions { get; }
        public Uri BaseUri { get; set; }
        public SyndicationElementExtensionCollection ElementExtensions { get; }
        public long Length { get; set; }
        public string MediaType { get; set; }
        public string RelationshipType { get; set; }
        public string Title { get; set; }
        public Uri Uri { get; set; }
        public virtual SyndicationLink Clone();
        public static SyndicationLink CreateAlternateLink(Uri uri);
        public static SyndicationLink CreateAlternateLink(Uri uri, string mediaType);
        public static SyndicationLink CreateMediaEnclosureLink(Uri uri, string mediaType, long length);
        public static SyndicationLink CreateSelfLink(Uri uri);
        public static SyndicationLink CreateSelfLink(Uri uri, string mediaType);
        public Uri GetAbsoluteUri();
        protected virtual bool TryParseAttribute(string name, string ns, string value, string version);
        protected virtual bool TryParseElement(XmlReader reader, string version);
        protected virtual void WriteAttributeExtensions(XmlWriter writer, string version);
        protected virtual void WriteElementExtensions(XmlWriter writer, string version);
    }

    public class SyndicationPerson
    {
        public SyndicationPerson();
        public SyndicationPerson(string email);
        public SyndicationPerson(string email, string name, string uri);
        protected SyndicationPerson(SyndicationPerson source);
        public Dictionary`2<XmlQualifiedName,string> AttributeExtensions { get; }
        public SyndicationElementExtensionCollection ElementExtensions { get; }
        public string Email { get; set; }
        public string Name { get; set; }
        public string Uri { get; set; }
        public virtual SyndicationPerson Clone();
        protected virtual bool TryParseAttribute(string name, string ns, string value, string version);
        protected virtual bool TryParseElement(XmlReader reader, string version);
        protected virtual void WriteAttributeExtensions(XmlWriter writer, string version);
        protected virtual void WriteElementExtensions(XmlWriter writer, string version);
    }

    public abstract sealed class SyndicationVersions
    {
        public const string Atom10;
        public const string Rss20;
    }

    public class TextSyndicationContent: SyndicationContent
    {
        public TextSyndicationContent(string text);
        public TextSyndicationContent(string text, TextSyndicationContentKind textKind);
        protected TextSyndicationContent(TextSyndicationContent source);
        public string Text { get; }
        public override SyndicationContent Clone();
        protected override void WriteContentsTo(XmlWriter writer);
    }

    public class UrlSyndicationContent: SyndicationContent
    {
        public UrlSyndicationContent(Uri url, string mediaType);
        protected UrlSyndicationContent(UrlSyndicationContent source);
        public Uri Url { get; }
        public override SyndicationContent Clone();
        protected override void WriteContentsTo(XmlWriter writer);
    }

    public class XmlSyndicationContent: SyndicationContent
    {
        public XmlSyndicationContent(string type, object dataContractExtension, XmlObjectSerializer dataContractSerializer);
        public XmlSyndicationContent(string type, object xmlSerializerExtension, XmlSerializer serializer);
        public XmlSyndicationContent(string type, SyndicationElementExtension extension);
        public XmlSyndicationContent(XmlReader reader);
        protected XmlSyndicationContent(XmlSyndicationContent source);
        public SyndicationElementExtension Extension { get; }
        public override SyndicationContent Clone();
        public XmlDictionaryReader GetReaderAtContent();
        public TContent ReadContent<TContent>();
        public TContent ReadContent<TContent>(XmlObjectSerializer dataContractSerializer);
        public TContent ReadContent<TContent>(XmlSerializer serializer);
        protected override void WriteContentsTo(XmlWriter writer);
    }

    public enum TextSyndicationContentKind
    {
        Html,
        Plaintext,
        XHtml,
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public sealed class SyndicationElementExtensionCollection: Collection`1, IList, IList`1
    {
        public void Add(object extension);
        public void Add(object dataContractExtension, DataContractSerializer serializer);
        public void Add(object xmlSerializerExtension, XmlSerializer serializer);
        public void Add(string outerName, string outerNamespace, object dataContractExtension);
        public void Add(string outerName, string outerNamespace, object dataContractExtension, XmlObjectSerializer dataContractSerializer);
        public void Add(XmlReader xmlReader);
        protected override void ClearItems();
        public XmlReader GetReaderAtElementExtensions();
        protected override void InsertItem(int index, SyndicationElementExtension item);
        public Collection`1<TExtension> ReadElementExtensions<TExtension>(string extensionName, string extensionNamespace);
        public Collection`1<TExtension> ReadElementExtensions<TExtension>(string extensionName, string extensionNamespace, XmlObjectSerializer serializer);
        public Collection`1<TExtension> ReadElementExtensions<TExtension>(string extensionName, string extensionNamespace, XmlSerializer serializer);
        protected override void RemoveItem(int index);
        protected override void SetItem(int index, SyndicationElementExtension item);
    }

} 

namespace System.Windows.Automation.Peers
{
    public class DescriptionViewerAutomationPeer: FrameworkElementAutomationPeer
    {
        public DescriptionViewerAutomationPeer(DescriptionViewer owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
    }

    public class ValidationSummaryAutomationPeer: FrameworkElementAutomationPeer, IInvokeProvider
    {
        public ValidationSummaryAutomationPeer(ValidationSummary owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

} 

namespace System.Windows.Controls
{
    [StyleTypedPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class DescriptionViewer: Control
    {
        public DescriptionViewer();
        public static readonly DependencyProperty DescriptionProperty;
        public static readonly DependencyProperty GlyphTemplateProperty;
        public static readonly DependencyProperty IsFocusedProperty;
        public static readonly DependencyProperty IsValidProperty;
        public static readonly DependencyProperty PropertyPathProperty;
        public static readonly DependencyProperty TargetProperty;
        public static readonly DependencyProperty ToolTipStyleProperty;
        public string Description { get; set; }
        public ControlTemplate GlyphTemplate { get; set; }
        protected bool IsFocused { get; set; }
        public bool IsValid { get; set; }
        public string PropertyPath { get; set; }
        public FrameworkElement Target { get; set; }
        public Style ToolTipStyle { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        public virtual void Refresh();
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class Label: ContentControl
    {
        public Label();
        public static readonly DependencyProperty IsRequiredProperty;
        public static readonly DependencyProperty IsValidProperty;
        public static readonly DependencyProperty PropertyPathProperty;
        public static readonly DependencyProperty TargetProperty;
        public bool IsRequired { get; set; }
        public bool IsValid { get; set; }
        public string PropertyPath { get; set; }
        public FrameworkElement Target { get; set; }
        public override void OnApplyTemplate();
        protected override void OnContentChanged(object oldContent, object newContent);
        public virtual void Refresh();
    }

    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ValidationSummary: Control
    {
        public ValidationSummary();
        public static readonly DependencyProperty ErrorStyleProperty;
        public static readonly DependencyProperty FilterProperty;
        public static readonly DependencyProperty FocusControlsOnClickProperty;
        public static readonly DependencyProperty HasDisplayedErrorsProperty;
        public static readonly DependencyProperty HasErrorsProperty;
        public static readonly DependencyProperty HeaderProperty;
        public static readonly DependencyProperty HeaderTemplateProperty;
        public static readonly DependencyProperty ShowErrorsInSummaryProperty;
        public static readonly DependencyProperty SummaryListBoxStyleProperty;
        public static readonly DependencyProperty TargetProperty;
        public ReadOnlyObservableCollection`1<ValidationSummaryItem> DisplayedErrors { get; }
        public ObservableCollection`1<ValidationSummaryItem> Errors { get; }
        public Style ErrorStyle { get; set; }
        public ValidationSummaryFilters Filter { get; set; }
        public bool FocusControlsOnClick { get; set; }
        public bool HasDisplayedErrors { get; set; }
        public bool HasErrors { get; set; }
        public object Header { get; set; }
        public DataTemplate HeaderTemplate { get; set; }
        public Style SummaryListBoxStyle { get; set; }
        public UIElement Target { get; set; }
        public static bool GetShowErrorsInSummary(DependencyObject inputControl);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnFocusingInvalidControl(FocusingInvalidControlEventArgs e);
        public static void SetShowErrorsInSummary(DependencyObject inputControl, bool value);
        public event EventHandler`1<FocusingInvalidControlEventArgs> FocusingInvalidControl;
        public event EventHandler`1<SelectionChangedEventArgs> SelectionChanged;
    }

    public class ValidationSummaryItem: INotifyPropertyChanged
    {
        public ValidationSummaryItem();
        public ValidationSummaryItem(string message);
        public ValidationSummaryItem(string message, string messageHeader, ValidationSummaryItemType itemType, ValidationSummaryItemSource source, object context);
        public object Context { get; set; }
        public ValidationSummaryItemType ItemType { get; set; }
        public string Message { get; set; }
        public string MessageHeader { get; set; }
        public ObservableCollection`1<ValidationSummaryItemSource> Sources { get; set; }
        public override string ToString();
        public event PropertyChangedEventHandler PropertyChanged;
    }

    public class ValidationSummaryItemSource
    {
        public ValidationSummaryItemSource(string propertyName);
        public ValidationSummaryItemSource(string propertyName, Control control);
        public Control Control { get; set; }
        public string PropertyName { get; set; }
        public override bool Equals(object obj);
        public override int GetHashCode();
    }

    [FlagsAttribute(..)]
    public enum ValidationSummaryFilters
    {
        All,
        None,
        ObjectErrors,
        PropertyErrors,
    }

    public enum ValidationSummaryItemType
    {
        ObjectError,
        PropertyError,
    }

    public class FocusingInvalidControlEventArgs: EventArgs
    {
        public FocusingInvalidControlEventArgs(ValidationSummaryItem item, ValidationSummaryItemSource target);
        public bool Handled { get; set; }
        public ValidationSummaryItem Item { get; set; }
        public ValidationSummaryItemSource Target { get; set; }
    }

} 

namespace System.ComponentModel
{
    [ObsoleteAttribute(..)]
    public class InvalidEnumArgumentException: Exception, _Exception, ISerializable
    {
        public InvalidEnumArgumentException();
        public InvalidEnumArgumentException(string message);
        public InvalidEnumArgumentException(string message, Exception innerException);
        public InvalidEnumArgumentException(string argumentName, int invalidValue, Type enumClass);
    }

} 

namespace System.Windows.Automation.Peers
{
    public class DataGridAutomationPeer: FrameworkElementAutomationPeer, IScrollProvider, ISelectionProvider, ITableProvider
    {
        public DataGridAutomationPeer(DataGrid owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class DataGridCellAutomationPeer: FrameworkElementAutomationPeer, IInvokeProvider, IScrollItemProvider, ISelectionItemProvider, ITableItemProvider
    {
        public DataGridCellAutomationPeer(DataGridCell owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
        protected override bool IsKeyboardFocusableCore();
    }

    public class DataGridColumnHeaderAutomationPeer: FrameworkElementAutomationPeer, IInvokeProvider, IScrollItemProvider, ITransformProvider
    {
        public DataGridColumnHeaderAutomationPeer(DataGridColumnHeader owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetHelpTextCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
        protected override bool IsContentElementCore();
    }

    public class DataGridColumnHeadersPresenterAutomationPeer: FrameworkElementAutomationPeer
    {
        public DataGridColumnHeadersPresenterAutomationPeer(DataGridColumnHeadersPresenter owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override bool IsContentElementCore();
    }

    public class DataGridDetailsPresenterAutomationPeer: FrameworkElementAutomationPeer
    {
        public DataGridDetailsPresenterAutomationPeer(DataGridDetailsPresenter owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override bool IsContentElementCore();
        protected override bool IsControlElementCore();
    }

    public class DataGridGroupItemAutomationPeer: FrameworkElementAutomationPeer, IExpandCollapseProvider, IGridProvider, IScrollItemProvider, ISelectionProvider
    {
        public DataGridGroupItemAutomationPeer(CollectionViewGroup group, DataGrid dataGrid);
        protected override string GetAcceleratorKeyCore();
        protected override string GetAccessKeyCore();
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetAutomationIdCore();
        protected override Rect GetBoundingRectangleCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        protected override Point GetClickablePointCore();
        protected override string GetHelpTextCore();
        protected override string GetItemStatusCore();
        protected override string GetItemTypeCore();
        protected override AutomationPeer GetLabeledByCore();
        protected override string GetLocalizedControlTypeCore();
        protected override string GetNameCore();
        protected override AutomationOrientation GetOrientationCore();
        public override object GetPattern(PatternInterface patternInterface);
        protected override bool HasKeyboardFocusCore();
        protected override bool IsContentElementCore();
        protected override bool IsControlElementCore();
        protected override bool IsEnabledCore();
        protected override bool IsKeyboardFocusableCore();
        protected override bool IsOffscreenCore();
        protected override bool IsPasswordCore();
        protected override bool IsRequiredForFormCore();
        protected override void SetFocusCore();
    }

    public class DataGridItemAutomationPeer: FrameworkElementAutomationPeer, IInvokeProvider, IScrollItemProvider, ISelectionItemProvider, ISelectionProvider
    {
        public DataGridItemAutomationPeer(object item, DataGrid dataGrid);
        protected override string GetAcceleratorKeyCore();
        protected override string GetAccessKeyCore();
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetAutomationIdCore();
        protected override Rect GetBoundingRectangleCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        protected override Point GetClickablePointCore();
        protected override string GetHelpTextCore();
        protected override string GetItemStatusCore();
        protected override string GetItemTypeCore();
        protected override AutomationPeer GetLabeledByCore();
        protected override string GetLocalizedControlTypeCore();
        protected override string GetNameCore();
        protected override AutomationOrientation GetOrientationCore();
        public override object GetPattern(PatternInterface patternInterface);
        protected override bool HasKeyboardFocusCore();
        protected override bool IsContentElementCore();
        protected override bool IsControlElementCore();
        protected override bool IsEnabledCore();
        protected override bool IsKeyboardFocusableCore();
        protected override bool IsOffscreenCore();
        protected override bool IsPasswordCore();
        protected override bool IsRequiredForFormCore();
        protected override void SetFocusCore();
    }

    public class DataGridRowAutomationPeer: FrameworkElementAutomationPeer
    {
        public DataGridRowAutomationPeer(DataGridRow owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
    }

    public class DataGridRowGroupHeaderAutomationPeer: FrameworkElementAutomationPeer
    {
        public DataGridRowGroupHeaderAutomationPeer(DataGridRowGroupHeader owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
    }

    public class DataGridRowHeaderAutomationPeer: FrameworkElementAutomationPeer
    {
        public DataGridRowHeaderAutomationPeer(DataGridRowHeader owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
        protected override bool IsContentElementCore();
    }

    public class DataGridRowsPresenterAutomationPeer: FrameworkElementAutomationPeer
    {
        public DataGridRowsPresenterAutomationPeer(DataGridRowsPresenter owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        protected override bool IsContentElementCore();
    }

    public class DataPagerAutomationPeer: FrameworkElementAutomationPeer, IRangeValueProvider
    {
        public DataPagerAutomationPeer(DataPager owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override Point GetClickablePointCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

} 

namespace System.Windows.Controls
{
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class DataGrid: Control
    {
        public DataGrid();
        public static readonly DependencyProperty AlternatingRowBackgroundProperty;
        public static readonly DependencyProperty AreRowDetailsFrozenProperty;
        public static readonly DependencyProperty AreRowGroupHeadersFrozenProperty;
        public static readonly DependencyProperty AutoGenerateColumnsProperty;
        public static readonly DependencyProperty CanUserReorderColumnsProperty;
        public static readonly DependencyProperty CanUserResizeColumnsProperty;
        public static readonly DependencyProperty CanUserSortColumnsProperty;
        public static readonly DependencyProperty CellStyleProperty;
        public static readonly DependencyProperty ClipboardCopyModeProperty;
        public static readonly DependencyProperty ColumnHeaderHeightProperty;
        public static readonly DependencyProperty ColumnHeaderStyleProperty;
        public static readonly DependencyProperty ColumnWidthProperty;
        public static readonly DependencyProperty DragIndicatorStyleProperty;
        public static readonly DependencyProperty DropLocationIndicatorStyleProperty;
        public static readonly DependencyProperty FrozenColumnCountProperty;
        public static readonly DependencyProperty GridLinesVisibilityProperty;
        public static readonly DependencyProperty HeadersVisibilityProperty;
        public static readonly DependencyProperty HorizontalGridLinesBrushProperty;
        public static readonly DependencyProperty HorizontalScrollBarVisibilityProperty;
        public static readonly DependencyProperty IsReadOnlyProperty;
        public static readonly DependencyProperty IsValidProperty;
        public static readonly DependencyProperty ItemsSourceProperty;
        public static readonly DependencyProperty MaxColumnWidthProperty;
        public static readonly DependencyProperty MinColumnWidthProperty;
        public static readonly DependencyProperty RowBackgroundProperty;
        public static readonly DependencyProperty RowDetailsTemplateProperty;
        public static readonly DependencyProperty RowDetailsVisibilityModeProperty;
        public static readonly DependencyProperty RowHeaderStyleProperty;
        public static readonly DependencyProperty RowHeaderWidthProperty;
        public static readonly DependencyProperty RowHeightProperty;
        public static readonly DependencyProperty RowStyleProperty;
        public static readonly DependencyProperty SelectedIndexProperty;
        public static readonly DependencyProperty SelectedItemProperty;
        public static readonly DependencyProperty SelectionModeProperty;
        public static readonly DependencyProperty VerticalGridLinesBrushProperty;
        public static readonly DependencyProperty VerticalScrollBarVisibilityProperty;
        public Brush AlternatingRowBackground { get; set; }
        public bool AreRowDetailsFrozen { get; set; }
        public bool AreRowGroupHeadersFrozen { get; set; }
        public bool AutoGenerateColumns { get; set; }
        public bool CanUserReorderColumns { get; set; }
        public bool CanUserResizeColumns { get; set; }
        public bool CanUserSortColumns { get; set; }
        public Style CellStyle { get; set; }
        public DataGridClipboardCopyMode ClipboardCopyMode { get; set; }
        public double ColumnHeaderHeight { get; set; }
        public Style ColumnHeaderStyle { get; set; }
        public ObservableCollection`1<DataGridColumn> Columns { get; }
        public DataGridLength ColumnWidth { get; set; }
        public DataGridColumn CurrentColumn { get; set; }
        protected object CurrentItem { get; }
        public Style DragIndicatorStyle { get; set; }
        public Style DropLocationIndicatorStyle { get; set; }
        public int FrozenColumnCount { get; set; }
        public DataGridGridLinesVisibility GridLinesVisibility { get; set; }
        public DataGridHeadersVisibility HeadersVisibility { get; set; }
        public Brush HorizontalGridLinesBrush { get; set; }
        public ScrollBarVisibility HorizontalScrollBarVisibility { get; set; }
        public bool IsReadOnly { get; set; }
        public bool IsValid { get; set; }
        public IEnumerable ItemsSource { get; set; }
        public double MaxColumnWidth { get; set; }
        public double MinColumnWidth { get; set; }
        public Brush RowBackground { get; set; }
        public DataTemplate RowDetailsTemplate { get; set; }
        public DataGridRowDetailsVisibilityMode RowDetailsVisibilityMode { get; set; }
        public ObservableCollection`1<Style> RowGroupHeaderStyles { get; }
        public Style RowHeaderStyle { get; set; }
        public double RowHeaderWidth { get; set; }
        public double RowHeight { get; set; }
        public Style RowStyle { get; set; }
        public int SelectedIndex { get; set; }
        public object SelectedItem { get; set; }
        public IList SelectedItems { get; }
        public DataGridSelectionMode SelectionMode { get; set; }
        public Brush VerticalGridLinesBrush { get; set; }
        public ScrollBarVisibility VerticalScrollBarVisibility { get; set; }
        protected override Size ArrangeOverride(Size finalSize);
        public bool BeginEdit();
        public bool BeginEdit(RoutedEventArgs editingEventArgs);
        public bool CancelEdit();
        public bool CancelEdit(DataGridEditingUnit editingUnit);
        public void CollapseRowGroup(CollectionViewGroup collectionViewGroup, bool collapseAllSubgroups);
        public bool CommitEdit();
        public bool CommitEdit(DataGridEditingUnit editingUnit, bool exitEditingMode);
        public void ExpandRowGroup(CollectionViewGroup collectionViewGroup, bool expandAllSubgroups);
        public CollectionViewGroup GetGroupFromItem(object item, int groupLevel);
        protected override Size MeasureOverride(Size availableSize);
        public override void OnApplyTemplate();
        protected virtual void OnAutoGeneratingColumn(DataGridAutoGeneratingColumnEventArgs e);
        protected virtual void OnBeginningEdit(DataGridBeginningEditEventArgs e);
        protected virtual void OnCellEditEnded(DataGridCellEditEndedEventArgs e);
        protected virtual void OnCellEditEnding(DataGridCellEditEndingEventArgs e);
        protected virtual void OnColumnDisplayIndexChanged(DataGridColumnEventArgs e);
        protected virtual void OnColumnReordered(DataGridColumnEventArgs e);
        protected virtual void OnColumnReordering(DataGridColumnReorderingEventArgs e);
        protected virtual void OnCopyingRowClipboardContent(DataGridRowClipboardEventArgs e);
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnCurrentCellChanged(EventArgs e);
        protected virtual void OnLoadingRow(DataGridRowEventArgs e);
        protected virtual void OnLoadingRowDetails(DataGridRowDetailsEventArgs e);
        protected virtual void OnLoadingRowGroup(DataGridRowGroupHeaderEventArgs e);
        protected override void OnMouseWheel(MouseWheelEventArgs e);
        protected virtual void OnPreparingCellForEdit(DataGridPreparingCellForEditEventArgs e);
        protected virtual void OnRowDetailsVisibilityChanged(DataGridRowDetailsEventArgs e);
        protected virtual void OnRowEditEnded(DataGridRowEditEndedEventArgs e);
        protected virtual void OnRowEditEnding(DataGridRowEditEndingEventArgs e);
        protected virtual void OnSelectionChanged(SelectionChangedEventArgs e);
        protected virtual void OnUnloadingRow(DataGridRowEventArgs e);
        protected virtual void OnUnloadingRowDetails(DataGridRowDetailsEventArgs e);
        protected virtual void OnUnloadingRowGroup(DataGridRowGroupHeaderEventArgs e);
        public void ScrollIntoView(object item, DataGridColumn column);
        public event EventHandler`1<DataGridAutoGeneratingColumnEventArgs> AutoGeneratingColumn;
        public event EventHandler`1<DataGridBeginningEditEventArgs> BeginningEdit;
        public event EventHandler`1<DataGridCellEditEndedEventArgs> CellEditEnded;
        public event EventHandler`1<DataGridCellEditEndingEventArgs> CellEditEnding;
        public event EventHandler`1<DataGridColumnEventArgs> ColumnDisplayIndexChanged;
        public event EventHandler`1<DragCompletedEventArgs> ColumnHeaderDragCompleted;
        public event EventHandler`1<DragDeltaEventArgs> ColumnHeaderDragDelta;
        public event EventHandler`1<DragStartedEventArgs> ColumnHeaderDragStarted;
        public event EventHandler`1<DataGridColumnEventArgs> ColumnReordered;
        public event EventHandler`1<DataGridColumnReorderingEventArgs> ColumnReordering;
        public event EventHandler`1<DataGridRowClipboardEventArgs> CopyingRowClipboardContent;
        public event EventHandler`1<EventArgs> CurrentCellChanged;
        public event EventHandler`1<DataGridRowEventArgs> LoadingRow;
        public event EventHandler`1<DataGridRowDetailsEventArgs> LoadingRowDetails;
        public event EventHandler`1<DataGridRowGroupHeaderEventArgs> LoadingRowGroup;
        public event EventHandler`1<DataGridPreparingCellForEditEventArgs> PreparingCellForEdit;
        public event EventHandler`1<DataGridRowDetailsEventArgs> RowDetailsVisibilityChanged;
        public event EventHandler`1<DataGridRowEditEndedEventArgs> RowEditEnded;
        public event EventHandler`1<DataGridRowEditEndingEventArgs> RowEditEnding;
        public event SelectionChangedEventHandler SelectionChanged;
        public event EventHandler`1<DataGridRowEventArgs> UnloadingRow;
        public event EventHandler`1<DataGridRowDetailsEventArgs> UnloadingRowDetails;
        public event EventHandler`1<DataGridRowGroupHeaderEventArgs> UnloadingRowGroup;
    }

    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    public abstract class DataGridBoundColumn: DataGridColumn
    {
        protected DataGridBoundColumn();
        public virtual Binding Binding { get; set; }
        public Style EditingElementStyle { get; set; }
        public Style ElementStyle { get; set; }
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class DataGridCell: ContentControl
    {
        public DataGridCell();
        public static readonly DependencyProperty IsValidProperty;
        public bool IsValid { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    public class DataGridCheckBoxColumn: DataGridBoundColumn
    {
        public DataGridCheckBoxColumn();
        public bool IsThreeState { get; set; }
        protected override void CancelCellEdit(FrameworkElement editingElement, object uneditedValue);
        protected override FrameworkElement GenerateEditingElement(DataGridCell cell, object dataItem);
        protected override FrameworkElement GenerateElement(DataGridCell cell, object dataItem);
        protected override object PrepareCellForEdit(FrameworkElement editingElement, RoutedEventArgs editingEventArgs);
        protected override void RefreshCellContent(FrameworkElement element, string propertyName);
    }

    public struct DataGridClipboardCellContent
    {
        public DataGridClipboardCellContent(object item, DataGridColumn column, object content);
        public DataGridColumn Column { get; }
        public object Content { get; }
        public object Item { get; }
        public override bool Equals(object obj);
        public override int GetHashCode();
        public static bool operator ==(DataGridClipboardCellContent clipboardCellContent1, DataGridClipboardCellContent clipboardCellContent2);
        public static bool operator !=(DataGridClipboardCellContent clipboardCellContent1, DataGridClipboardCellContent clipboardCellContent2);
    }

    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    public abstract class DataGridColumn: DependencyObject
    {
        protected DataGridColumn();
        public double ActualWidth { get; }
        public bool CanUserReorder { get; set; }
        public bool CanUserResize { get; set; }
        public bool CanUserSort { get; set; }
        public Style CellStyle { get; set; }
        public virtual Binding ClipboardContentBinding { get; set; }
        public int DisplayIndex { get; set; }
        public Style DragIndicatorStyle { get; set; }
        public object Header { get; set; }
        public Style HeaderStyle { get; set; }
        public bool IsAutoGenerated { get; set; }
        public bool IsFrozen { get; set; }
        public bool IsReadOnly { get; set; }
        public double MaxWidth { get; set; }
        public double MinWidth { get; set; }
        public string SortMemberPath { get; set; }
        public Visibility Visibility { get; set; }
        public DataGridLength Width { get; set; }
        protected virtual void CancelCellEdit(FrameworkElement editingElement, object uneditedValue);
        protected abstract FrameworkElement GenerateEditingElement(DataGridCell cell, object dataItem);
        protected abstract FrameworkElement GenerateElement(DataGridCell cell, object dataItem);
        public FrameworkElement GetCellContent(DataGridRow dataGridRow);
        public FrameworkElement GetCellContent(object dataItem);
        public static DataGridColumn GetColumnContainingElement(FrameworkElement element);
        protected void NotifyPropertyChanged(string propertyName);
        protected abstract object PrepareCellForEdit(FrameworkElement editingElement, RoutedEventArgs editingEventArgs);
        protected virtual void RefreshCellContent(FrameworkElement element, string propertyName);
    }

    [TypeConverterAttribute(..)]
    public struct DataGridLength: IEquatable`1
    {
        public DataGridLength(double value);
        public DataGridLength(double value, DataGridLengthUnitType type);
        public DataGridLength(double value, DataGridLengthUnitType type, double desiredValue, double displayValue);
        public static DataGridLength Auto { get; }
        public double DesiredValue { get; }
        public double DisplayValue { get; }
        public bool IsAbsolute { get; }
        public bool IsAuto { get; }
        public bool IsSizeToCells { get; }
        public bool IsSizeToHeader { get; }
        public bool IsStar { get; }
        public static DataGridLength SizeToCells { get; }
        public static DataGridLength SizeToHeader { get; }
        public DataGridLengthUnitType UnitType { get; }
        public double Value { get; }
        public bool Equals(DataGridLength other);
        public override bool Equals(object obj);
        public override int GetHashCode();
        public static bool operator ==(DataGridLength gl1, DataGridLength gl2);
        public static bool operator !=(DataGridLength gl1, DataGridLength gl2);
    }

    public class DataGridLengthConverter: TypeConverter
    {
        public DataGridLengthConverter();
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
    }

    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class DataGridRow: Control
    {
        public DataGridRow();
        public static readonly DependencyProperty DetailsTemplateProperty;
        public static readonly DependencyProperty DetailsVisibilityProperty;
        public static readonly DependencyProperty HeaderProperty;
        public static readonly DependencyProperty HeaderStyleProperty;
        public static readonly DependencyProperty IsValidProperty;
        public DataTemplate DetailsTemplate { get; set; }
        public Visibility DetailsVisibility { get; set; }
        public object Header { get; set; }
        public Style HeaderStyle { get; set; }
        public bool IsValid { get; set; }
        protected override Size ArrangeOverride(Size finalSize);
        public int GetIndex();
        public static DataGridRow GetRowContainingElement(FrameworkElement element);
        protected override Size MeasureOverride(Size availableSize);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    public class DataGridRowGroupHeader: Control
    {
        public DataGridRowGroupHeader();
        public static readonly DependencyProperty HeaderStyleProperty;
        public static readonly DependencyProperty ItemCountVisibilityProperty;
        public static readonly DependencyProperty PropertyNameProperty;
        public static readonly DependencyProperty PropertyNameVisibilityProperty;
        public static readonly DependencyProperty SublevelIndentProperty;
        public Style HeaderStyle { get; set; }
        public Visibility ItemCountVisibility { get; set; }
        public string PropertyName { get; set; }
        public Visibility PropertyNameVisibility { get; set; }
        public double SublevelIndent { get; set; }
        protected override Size ArrangeOverride(Size finalSize);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
    }

    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    public class DataGridTemplateColumn: DataGridColumn
    {
        public DataGridTemplateColumn();
        public DataTemplate CellEditingTemplate { get; set; }
        public DataTemplate CellTemplate { get; set; }
        protected override void CancelCellEdit(FrameworkElement editingElement, object uneditedValue);
        protected override FrameworkElement GenerateEditingElement(DataGridCell cell, object dataItem);
        protected override FrameworkElement GenerateElement(DataGridCell cell, object dataItem);
        protected override object PrepareCellForEdit(FrameworkElement editingElement, RoutedEventArgs editingEventArgs);
    }

    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    public class DataGridTextColumn: DataGridBoundColumn
    {
        public DataGridTextColumn();
        public static readonly DependencyProperty FontFamilyProperty;
        public FontFamily FontFamily { get; set; }
        public double FontSize { get; set; }
        public FontStyle FontStyle { get; set; }
        public FontWeight FontWeight { get; set; }
        public Brush Foreground { get; set; }
        protected override void CancelCellEdit(FrameworkElement editingElement, object uneditedValue);
        protected override FrameworkElement GenerateEditingElement(DataGridCell cell, object dataItem);
        protected override FrameworkElement GenerateElement(DataGridCell cell, object dataItem);
        protected override object PrepareCellForEdit(FrameworkElement editingElement, RoutedEventArgs editingEventArgs);
        protected override void RefreshCellContent(FrameworkElement element, string propertyName);
    }

    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class DataPager: Control
    {
        public DataPager();
        public static readonly DependencyProperty AutoEllipsisProperty;
        public static readonly DependencyProperty CanChangePageProperty;
        public static readonly DependencyProperty CanMoveToFirstPageProperty;
        public static readonly DependencyProperty CanMoveToLastPageProperty;
        public static readonly DependencyProperty CanMoveToNextPageProperty;
        public static readonly DependencyProperty CanMoveToPreviousPageProperty;
        public static readonly DependencyProperty DisplayModeProperty;
        public static readonly DependencyProperty IsTotalItemCountFixedProperty;
        public static readonly DependencyProperty ItemCountProperty;
        public static readonly DependencyProperty NumericButtonCountProperty;
        public static readonly DependencyProperty NumericButtonStyleProperty;
        public static readonly DependencyProperty PageCountProperty;
        public static readonly DependencyProperty PageIndexProperty;
        public static readonly DependencyProperty PageSizeProperty;
        public static readonly DependencyProperty SourceProperty;
        public bool AutoEllipsis { get; set; }
        public bool CanChangePage { get; set; }
        public bool CanMoveToFirstPage { get; set; }
        public bool CanMoveToLastPage { get; set; }
        public bool CanMoveToNextPage { get; set; }
        public bool CanMoveToPreviousPage { get; set; }
        public PagerDisplayMode DisplayMode { get; set; }
        public bool IsTotalItemCountFixed { get; set; }
        public int ItemCount { get; set; }
        public int NumericButtonCount { get; set; }
        public Style NumericButtonStyle { get; set; }
        public int PageCount { get; set; }
        public int PageIndex { get; set; }
        public int PageSize { get; set; }
        public IEnumerable Source { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        public event EventHandler`1<EventArgs> PageIndexChanged;
        public event EventHandler`1<CancelEventArgs> PageIndexChanging;
    }

    public enum DataGridClipboardCopyMode
    {
        ExcludeHeader,
        IncludeHeader,
        None,
    }

    public enum DataGridEditAction
    {
        Cancel,
        Commit,
    }

    public enum DataGridEditingUnit
    {
        Cell,
        Row,
    }

    [FlagsAttribute(..)]
    public enum DataGridGridLinesVisibility
    {
        All,
        Horizontal,
        None,
        Vertical,
    }

    [FlagsAttribute(..)]
    public enum DataGridHeadersVisibility
    {
        All,
        Column,
        None,
        Row,
    }

    public enum DataGridLengthUnitType
    {
        Auto,
        Pixel,
        SizeToCells,
        SizeToHeader,
        Star,
    }

    public enum DataGridRowDetailsVisibilityMode
    {
        Collapsed,
        Visible,
        VisibleWhenSelected,
    }

    public enum DataGridSelectionMode
    {
        Extended,
        Single,
    }

    public enum PagerDisplayMode
    {
        FirstLastNumeric,
        FirstLastPreviousNext,
        FirstLastPreviousNextNumeric,
        Numeric,
        PreviousNext,
        PreviousNextNumeric,
    }

    public class DataGridAutoGeneratingColumnEventArgs: CancelEventArgs
    {
        public DataGridAutoGeneratingColumnEventArgs(string propertyName, Type propertyType, DataGridColumn column);
        public DataGridColumn Column { get; set; }
        public string PropertyName { get; set; }
        public Type PropertyType { get; set; }
    }

    public class DataGridBeginningEditEventArgs: CancelEventArgs
    {
        public DataGridBeginningEditEventArgs(DataGridColumn column, DataGridRow row, RoutedEventArgs editingEventArgs);
        public DataGridColumn Column { get; set; }
        public RoutedEventArgs EditingEventArgs { get; set; }
        public DataGridRow Row { get; set; }
    }

    public class DataGridCellEditEndedEventArgs: EventArgs
    {
        public DataGridCellEditEndedEventArgs(DataGridColumn column, DataGridRow row, DataGridEditAction editAction);
        public DataGridColumn Column { get; set; }
        public DataGridEditAction EditAction { get; set; }
        public DataGridRow Row { get; set; }
    }

    public class DataGridCellEditEndingEventArgs: CancelEventArgs
    {
        public DataGridCellEditEndingEventArgs(DataGridColumn column, DataGridRow row, FrameworkElement editingElement, DataGridEditAction editAction);
        public DataGridColumn Column { get; set; }
        public DataGridEditAction EditAction { get; set; }
        public FrameworkElement EditingElement { get; set; }
        public DataGridRow Row { get; set; }
    }

    public class DataGridColumnEventArgs: EventArgs
    {
        public DataGridColumnEventArgs(DataGridColumn column);
        public DataGridColumn Column { get; set; }
    }

    public class DataGridColumnReorderingEventArgs: CancelEventArgs
    {
        public DataGridColumnReorderingEventArgs(DataGridColumn dataGridColumn);
        public DataGridColumn Column { get; set; }
        public Control DragIndicator { get; set; }
        public Control DropLocationIndicator { get; set; }
    }

    public class DataGridPreparingCellForEditEventArgs: EventArgs
    {
        public DataGridPreparingCellForEditEventArgs(DataGridColumn column, DataGridRow row, RoutedEventArgs editingEventArgs, FrameworkElement editingElement);
        public DataGridColumn Column { get; set; }
        public FrameworkElement EditingElement { get; set; }
        public RoutedEventArgs EditingEventArgs { get; set; }
        public DataGridRow Row { get; set; }
    }

    public class DataGridRowClipboardEventArgs: EventArgs
    {
        public List`1<DataGridClipboardCellContent> ClipboardRowContent { get; }
        public bool IsColumnHeadersRow { get; }
        public object Item { get; }
    }

    public class DataGridRowDetailsEventArgs: EventArgs
    {
        public DataGridRowDetailsEventArgs(DataGridRow row, FrameworkElement detailsElement);
        public FrameworkElement DetailsElement { get; set; }
        public DataGridRow Row { get; set; }
    }

    public class DataGridRowEditEndedEventArgs: EventArgs
    {
        public DataGridRowEditEndedEventArgs(DataGridRow row, DataGridEditAction editAction);
        public DataGridEditAction EditAction { get; set; }
        public DataGridRow Row { get; set; }
    }

    public class DataGridRowEditEndingEventArgs: CancelEventArgs
    {
        public DataGridRowEditEndingEventArgs(DataGridRow row, DataGridEditAction editAction);
        public DataGridEditAction EditAction { get; set; }
        public DataGridRow Row { get; set; }
    }

    public class DataGridRowEventArgs: EventArgs
    {
        public DataGridRowEventArgs(DataGridRow dataGridRow);
        public DataGridRow Row { get; set; }
    }

    public class DataGridRowGroupHeaderEventArgs: EventArgs
    {
        public DataGridRowGroupHeaderEventArgs(DataGridRowGroupHeader rowGroupHeader);
        public DataGridRowGroupHeader RowGroupHeader { get; set; }
    }

} 

namespace System.Windows.Controls.Primitives
{
    [ContentPropertyAttribute(..)]
    public sealed class DataGridCellsPresenter: Panel
    {
        public DataGridCellsPresenter();
        protected override Size ArrangeOverride(Size finalSize);
        protected override Size MeasureOverride(Size availableSize);
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class DataGridColumnHeader: ContentControl
    {
        public DataGridColumnHeader();
        public static readonly DependencyProperty SeparatorBrushProperty;
        public static readonly DependencyProperty SeparatorVisibilityProperty;
        public Brush SeparatorBrush { get; set; }
        public Visibility SeparatorVisibility { get; set; }
        public override void OnApplyTemplate();
        protected override void OnContentChanged(object oldContent, object newContent);
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [ContentPropertyAttribute(..)]
    public sealed class DataGridColumnHeadersPresenter: Panel
    {
        public DataGridColumnHeadersPresenter();
        protected override Size ArrangeOverride(Size finalSize);
        protected override Size MeasureOverride(Size availableSize);
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [ContentPropertyAttribute(..)]
    public sealed class DataGridDetailsPresenter: Panel
    {
        public DataGridDetailsPresenter();
        public static readonly DependencyProperty ContentHeightProperty;
        public double ContentHeight { get; set; }
        protected override Size ArrangeOverride(Size finalSize);
        protected override Size MeasureOverride(Size availableSize);
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [ContentPropertyAttribute(..)]
    public class DataGridFrozenGrid: Grid
    {
        public DataGridFrozenGrid();
        public static readonly DependencyProperty IsFrozenProperty;
        public static bool GetIsFrozen(DependencyObject element);
        public static void SetIsFrozen(DependencyObject element, bool value);
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class DataGridRowHeader: ContentControl
    {
        public DataGridRowHeader();
        public static readonly DependencyProperty SeparatorBrushProperty;
        public static readonly DependencyProperty SeparatorVisibilityProperty;
        public Brush SeparatorBrush { get; set; }
        public Visibility SeparatorVisibility { get; set; }
        protected override Size MeasureOverride(Size availableSize);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [ContentPropertyAttribute(..)]
    public sealed class DataGridRowsPresenter: Panel
    {
        public DataGridRowsPresenter();
        protected override Size ArrangeOverride(Size finalSize);
        protected override Size MeasureOverride(Size availableSize);
        protected override AutomationPeer OnCreateAutomationPeer();
    }

} 

namespace System.Windows
{
    public class HierarchicalDataTemplate: DataTemplate
    {
        public HierarchicalDataTemplate();
        public Style ItemContainerStyle { get; set; }
        public Binding ItemsSource { get; set; }
        public DataTemplate ItemTemplate { get; set; }
    }

} 

namespace System.Windows.Automation.Peers
{
    public class CalendarAutomationPeer: FrameworkElementAutomationPeer, IMultipleViewProvider, ISelectionProvider, ITableProvider
    {
        public CalendarAutomationPeer(Calendar owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class CalendarButtonAutomationPeer: FrameworkElementAutomationPeer, IGridItemProvider, IInvokeProvider, ISelectionItemProvider
    {
        public CalendarButtonAutomationPeer(CalendarButton owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetHelpTextCore();
        protected override string GetLocalizedControlTypeCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class CalendarDayButtonAutomationPeer: FrameworkElementAutomationPeer, IInvokeProvider, ISelectionItemProvider, ITableItemProvider
    {
        public CalendarDayButtonAutomationPeer(CalendarDayButton owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetHelpTextCore();
        protected override string GetLocalizedControlTypeCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class ChildWindowAutomationPeer: FrameworkElementAutomationPeer, ITransformProvider, IWindowProvider
    {
        public ChildWindowAutomationPeer(ChildWindow owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class DatePickerAutomationPeer: FrameworkElementAutomationPeer, IExpandCollapseProvider, IValueProvider
    {
        public DatePickerAutomationPeer(DatePicker owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetLocalizedControlTypeCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class GridSplitterAutomationPeer: FrameworkElementAutomationPeer, ITransformProvider
    {
        public GridSplitterAutomationPeer(GridSplitter owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class TabControlAutomationPeer: ItemsControlAutomationPeer, ISelectionProvider
    {
        public TabControlAutomationPeer(TabControl owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override Point GetClickablePointCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class TabItemAutomationPeer: ItemAutomationPeer, ISelectionItemProvider
    {
        public TabItemAutomationPeer(object owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class TreeViewAutomationPeer: FrameworkElementAutomationPeer, ISelectionProvider
    {
        public TreeViewAutomationPeer(TreeView owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

    public class TreeViewItemAutomationPeer: FrameworkElementAutomationPeer, IExpandCollapseProvider, IScrollItemProvider, ISelectionItemProvider
    {
        public TreeViewItemAutomationPeer(TreeViewItem owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

} 

namespace System.Windows.Controls
{
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class Calendar: Control
    {
        public Calendar();
        public static readonly DependencyProperty CalendarButtonStyleProperty;
        public static readonly DependencyProperty CalendarDayButtonStyleProperty;
        public static readonly DependencyProperty CalendarItemStyleProperty;
        public static readonly DependencyProperty DisplayDateEndProperty;
        public static readonly DependencyProperty DisplayDateProperty;
        public static readonly DependencyProperty DisplayDateStartProperty;
        public static readonly DependencyProperty DisplayModeProperty;
        public static readonly DependencyProperty FirstDayOfWeekProperty;
        public static readonly DependencyProperty IsTodayHighlightedProperty;
        public static readonly DependencyProperty SelectedDateProperty;
        public static readonly DependencyProperty SelectionModeProperty;
        public CalendarBlackoutDatesCollection BlackoutDates { get; set; }
        public Style CalendarButtonStyle { get; set; }
        public Style CalendarDayButtonStyle { get; set; }
        public Style CalendarItemStyle { get; set; }
        public DateTime DisplayDate { get; set; }
        public Nullable`1<DateTime> DisplayDateEnd { get; set; }
        public Nullable`1<DateTime> DisplayDateStart { get; set; }
        public CalendarMode DisplayMode { get; set; }
        public DayOfWeek FirstDayOfWeek { get; set; }
        public bool IsTodayHighlighted { get; set; }
        public Nullable`1<DateTime> SelectedDate { get; set; }
        public SelectedDatesCollection SelectedDates { get; set; }
        public CalendarSelectionMode SelectionMode { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnMouseWheel(MouseWheelEventArgs e);
        public override string ToString();
        public event EventHandler`1<CalendarDateChangedEventArgs> DisplayDateChanged;
        public event EventHandler`1<CalendarModeChangedEventArgs> DisplayModeChanged;
        public event EventHandler`1<SelectionChangedEventArgs> SelectedDatesChanged;
    }

    public sealed class CalendarDateRange
    {
        public CalendarDateRange(DateTime day);
        public CalendarDateRange(DateTime start, DateTime end);
        public DateTime End { get; set; }
        public DateTime Start { get; set; }
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class ChildWindow: ContentControl
    {
        public ChildWindow();
        public static readonly DependencyProperty HasCloseButtonProperty;
        public static readonly DependencyProperty OverlayBrushProperty;
        public static readonly DependencyProperty OverlayOpacityProperty;
        public static readonly DependencyProperty TitleProperty;
        public Nullable`1<bool> DialogResult { get; set; }
        public bool HasCloseButton { get; set; }
        public Brush OverlayBrush { get; set; }
        public double OverlayOpacity { get; set; }
        public object Title { get; set; }
        public void Close();
        public override void OnApplyTemplate();
        protected virtual void OnClosed(EventArgs e);
        protected virtual void OnClosing(CancelEventArgs e);
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnOpened();
        public void Show();
        public event EventHandler Closed;
        public event EventHandler`1<CancelEventArgs> Closing;
    }

    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class DatePicker: Control
    {
        public DatePicker();
        public static readonly DependencyProperty CalendarStyleProperty;
        public static readonly DependencyProperty DisplayDateEndProperty;
        public static readonly DependencyProperty DisplayDateProperty;
        public static readonly DependencyProperty DisplayDateStartProperty;
        public static readonly DependencyProperty FirstDayOfWeekProperty;
        public static readonly DependencyProperty IsDropDownOpenProperty;
        public static readonly DependencyProperty IsTodayHighlightedProperty;
        public static readonly DependencyProperty SelectedDateFormatProperty;
        public static readonly DependencyProperty SelectedDateProperty;
        public static readonly DependencyProperty SelectionBackgroundProperty;
        public static readonly DependencyProperty TextProperty;
        public CalendarBlackoutDatesCollection BlackoutDates { get; set; }
        public Style CalendarStyle { get; set; }
        public DateTime DisplayDate { get; set; }
        public Nullable`1<DateTime> DisplayDateEnd { get; set; }
        public Nullable`1<DateTime> DisplayDateStart { get; set; }
        public DayOfWeek FirstDayOfWeek { get; set; }
        public bool IsDropDownOpen { get; set; }
        public bool IsTodayHighlighted { get; set; }
        public Nullable`1<DateTime> SelectedDate { get; set; }
        public DatePickerFormat SelectedDateFormat { get; set; }
        public Brush SelectionBackground { get; set; }
        public string Text { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnDateValidationError(DatePickerDateValidationErrorEventArgs e);
        protected override void OnMouseWheel(MouseWheelEventArgs e);
        public override string ToString();
        public event RoutedEventHandler CalendarClosed;
        public event RoutedEventHandler CalendarOpened;
        public event EventHandler`1<DatePickerDateValidationErrorEventArgs> DateValidationError;
        public event EventHandler`1<SelectionChangedEventArgs> SelectedDateChanged;
    }

    public class DateTimeTypeConverter: TypeConverter
    {
        public DateTimeTypeConverter();
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
    }

    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class GridSplitter: Control
    {
        public GridSplitter();
        public static readonly DependencyProperty PreviewStyleProperty;
        public static readonly DependencyProperty ShowsPreviewProperty;
        public Style PreviewStyle { get; set; }
        public bool ShowsPreview { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
    }

    [ContentPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    public class HeaderedItemsControl: ItemsControl
    {
        public HeaderedItemsControl();
        public static readonly DependencyProperty HeaderProperty;
        public static readonly DependencyProperty HeaderTemplateProperty;
        public static readonly DependencyProperty ItemContainerStyleProperty;
        public object Header { get; set; }
        public DataTemplate HeaderTemplate { get; set; }
        public Style ItemContainerStyle { get; set; }
        public override void OnApplyTemplate();
        protected virtual void OnHeaderChanged(object oldHeader, object newHeader);
        protected virtual void OnHeaderTemplateChanged(DataTemplate oldHeaderTemplate, DataTemplate newHeaderTemplate);
        protected override void PrepareContainerForItemOverride(DependencyObject element, object item);
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class TabControl: ItemsControl
    {
        public TabControl();
        public static readonly DependencyProperty SelectedContentProperty;
        public static readonly DependencyProperty SelectedIndexProperty;
        public static readonly DependencyProperty SelectedItemProperty;
        public static readonly DependencyProperty TabStripPlacementProperty;
        public object SelectedContent { get; set; }
        public int SelectedIndex { get; set; }
        public object SelectedItem { get; set; }
        public Dock TabStripPlacement { get; set; }
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected virtual void OnSelectionChanged(SelectionChangedEventArgs args);
        public event SelectionChangedEventHandler SelectionChanged;
    }

    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class TabItem: ContentControl
    {
        public TabItem();
        public static readonly DependencyProperty HasHeaderProperty;
        public static readonly DependencyProperty HeaderProperty;
        public static readonly DependencyProperty HeaderTemplateProperty;
        public static readonly DependencyProperty IsFocusedProperty;
        public static readonly DependencyProperty IsSelectedProperty;
        public bool HasHeader { get; set; }
        public object Header { get; set; }
        public DataTemplate HeaderTemplate { get; set; }
        public bool IsFocused { get; set; }
        public bool IsSelected { get; set; }
        public Dock TabStripPlacement { get; }
        public override void OnApplyTemplate();
        protected override void OnContentChanged(object oldContent, object newContent);
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnHeaderChanged(object oldHeader, object newHeader);
        protected virtual void OnHeaderTemplateChanged(DataTemplate oldHeaderTemplate, DataTemplate newHeaderTemplate);
        protected virtual void OnIsFocusChanged(DependencyPropertyChangedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected virtual void OnSelected(RoutedEventArgs e);
        protected virtual void OnUnselected(RoutedEventArgs e);
    }

    [ContentPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class TreeView: ItemsControl
    {
        public TreeView();
        public static readonly DependencyProperty ItemContainerStyleProperty;
        public static readonly DependencyProperty SelectedItemProperty;
        public static readonly DependencyProperty SelectedValuePathProperty;
        public static readonly DependencyProperty SelectedValueProperty;
        public Style ItemContainerStyle { get; set; }
        public object SelectedItem { get; set; }
        public object SelectedValue { get; set; }
        public string SelectedValuePath { get; set; }
        protected override void ClearContainerForItemOverride(DependencyObject element, object item);
        protected override DependencyObject GetContainerForItemOverride();
        protected override bool IsItemItsOwnContainerOverride(object item);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnKeyUp(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected override void OnMouseMove(MouseEventArgs e);
        protected virtual void OnSelectedItemChanged(RoutedPropertyChangedEventArgs`1<object> e);
        protected override void PrepareContainerForItemOverride(DependencyObject element, object item);
        public event RoutedPropertyChangedEventHandler`1<object> SelectedItemChanged;
    }

    [ContentPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class TreeViewItem: HeaderedItemsControl
    {
        public TreeViewItem();
        public static readonly DependencyProperty HasItemsProperty;
        public static readonly DependencyProperty IsExpandedProperty;
        public static readonly DependencyProperty IsSelectedProperty;
        public static readonly DependencyProperty IsSelectionActiveProperty;
        public bool HasItems { get; set; }
        public bool IsExpanded { get; set; }
        public bool IsSelected { get; set; }
        public bool IsSelectionActive { get; set; }
        protected override void ClearContainerForItemOverride(DependencyObject element, object item);
        protected override DependencyObject GetContainerForItemOverride();
        protected override bool IsItemItsOwnContainerOverride(object item);
        public override void OnApplyTemplate();
        protected virtual void OnCollapsed(RoutedEventArgs e);
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnExpanded(RoutedEventArgs e);
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnItemsChanged(NotifyCollectionChangedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnKeyUp(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected override void OnMouseEnter(MouseEventArgs e);
        protected override void OnMouseLeave(MouseEventArgs e);
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        protected virtual void OnSelected(RoutedEventArgs e);
        protected virtual void OnUnselected(RoutedEventArgs e);
        protected override void PrepareContainerForItemOverride(DependencyObject element, object item);
        public event RoutedEventHandler Collapsed;
        public event RoutedEventHandler Expanded;
        public event RoutedEventHandler Selected;
        public event RoutedEventHandler Unselected;
    }

    public enum CalendarMode
    {
        Decade,
        Month,
        Year,
    }

    public enum CalendarSelectionMode
    {
        MultipleRange,
        None,
        SingleDate,
        SingleRange,
    }

    public enum DatePickerFormat
    {
        Long,
        Short,
    }

    public enum Dock
    {
        Bottom,
        Left,
        Right,
        Top,
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public sealed class CalendarBlackoutDatesCollection: ObservableCollection`1, IList, IList`1, INotifyCollectionChanged, INotifyPropertyChanged
    {
        public CalendarBlackoutDatesCollection(Calendar owner);
        public void AddDatesInPast();
        protected override void ClearItems();
        public bool Contains(DateTime date);
        public bool Contains(DateTime start, DateTime end);
        public bool ContainsAny(CalendarDateRange range);
        protected override void InsertItem(int index, CalendarDateRange item);
        protected override void RemoveItem(int index);
        protected override void SetItem(int index, CalendarDateRange item);
    }

    [DebuggerDisplayAttribute(..)]
    [DebuggerTypeProxyAttribute(..)]
    [DefaultMemberAttribute(..)]
    public sealed class SelectedDatesCollection: ObservableCollection`1, IList, IList`1, INotifyCollectionChanged, INotifyPropertyChanged
    {
        public SelectedDatesCollection(Calendar owner);
        public void AddRange(DateTime start, DateTime end);
        protected override void ClearItems();
        protected override void InsertItem(int index, DateTime item);
        protected override void RemoveItem(int index);
        protected override void SetItem(int index, DateTime item);
    }

    public class CalendarDateChangedEventArgs: RoutedEventArgs
    {
        public Nullable`1<DateTime> AddedDate { get; set; }
        public Nullable`1<DateTime> RemovedDate { get; set; }
    }

    public class CalendarModeChangedEventArgs: RoutedEventArgs
    {
        public CalendarModeChangedEventArgs(CalendarMode oldMode, CalendarMode newMode);
        public CalendarMode NewMode { get; set; }
        public CalendarMode OldMode { get; set; }
    }

    public class DatePickerDateValidationErrorEventArgs: EventArgs
    {
        public DatePickerDateValidationErrorEventArgs(Exception exception, string text);
        public Exception Exception { get; set; }
        public string Text { get; set; }
        public bool ThrowException { get; set; }
    }

    public class RoutedPropertyChangingEventArgs`1<T>: RoutedEventArgs
    {
        public RoutedPropertyChangingEventArgs`1(DependencyProperty property, T oldValue, T newValue, bool isCancelable);
        public bool Cancel { get; set; }
        public bool InCoercion { get; set; }
        public bool IsCancelable { get; set; }
        public T NewValue { get; set; }
        public T OldValue { get; set; }
        public DependencyProperty Property { get; set; }
    }

    public delegate void RoutedPropertyChangingEventHandler`1<T>(object sender, RoutedPropertyChangingEventArgs`1<T> e);

} 

namespace System.Windows.Controls.Primitives
{
    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class CalendarButton: Button
    {
        public CalendarButton();
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        public event MouseButtonEventHandler CalendarButtonMouseDown;
        public event MouseButtonEventHandler CalendarButtonMouseUp;
    }

    [ContentPropertyAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class CalendarDayButton: Button
    {
        public CalendarDayButton();
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e);
        protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e);
        public event MouseButtonEventHandler CalendarDayButtonMouseDown;
        public event MouseButtonEventHandler CalendarDayButtonMouseUp;
    }

    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class CalendarItem: Control
    {
        public CalendarItem();
        public override void OnApplyTemplate();
    }

    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public sealed class DatePickerTextBox: TextBox
    {
        public DatePickerTextBox();
        public static readonly DependencyProperty WatermarkProperty;
        public object Watermark { get; set; }
        public override void OnApplyTemplate();
    }

    [ContentPropertyAttribute(..)]
    public class TabPanel: Panel
    {
        public TabPanel();
        protected override Size ArrangeOverride(Size finalSize);
        protected override Size MeasureOverride(Size availableSize);
    }

} 

namespace System.Windows.Automation.Peers
{
    public sealed class AutoCompleteBoxAutomationPeer: FrameworkElementAutomationPeer, IExpandCollapseProvider, ISelectionProvider, IValueProvider
    {
        public AutoCompleteBoxAutomationPeer(AutoCompleteBox owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override List`1<AutomationPeer> GetChildrenCore();
        protected override string GetClassNameCore();
        public override object GetPattern(PatternInterface patternInterface);
    }

} 

namespace System.Windows.Controls
{
    [ContentPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [StyleTypedPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    [TemplateVisualStateAttribute(..)]
    public class AutoCompleteBox: Control
    {
        public AutoCompleteBox();
        public static readonly DependencyProperty FilterModeProperty;
        public static readonly DependencyProperty IsDropDownOpenProperty;
        public static readonly DependencyProperty IsTextCompletionEnabledProperty;
        public static readonly DependencyProperty ItemContainerStyleProperty;
        public static readonly DependencyProperty ItemFilterProperty;
        public static readonly DependencyProperty ItemsSourceProperty;
        public static readonly DependencyProperty ItemTemplateProperty;
        public static readonly DependencyProperty MaxDropDownHeightProperty;
        public static readonly DependencyProperty MinimumPopulateDelayProperty;
        public static readonly DependencyProperty MinimumPrefixLengthProperty;
        public static readonly DependencyProperty SearchTextProperty;
        public static readonly DependencyProperty SelectedItemProperty;
        public static readonly DependencyProperty TextBoxStyleProperty;
        public static readonly DependencyProperty TextFilterProperty;
        public static readonly DependencyProperty TextProperty;
        public AutoCompleteFilterMode FilterMode { get; set; }
        public bool IsDropDownOpen { get; set; }
        public bool IsTextCompletionEnabled { get; set; }
        public Style ItemContainerStyle { get; set; }
        public AutoCompleteFilterPredicate`1<object> ItemFilter { get; set; }
        public IEnumerable ItemsSource { get; set; }
        public DataTemplate ItemTemplate { get; set; }
        public double MaxDropDownHeight { get; set; }
        public int MinimumPopulateDelay { get; set; }
        public int MinimumPrefixLength { get; set; }
        public string SearchText { get; set; }
        public object SelectedItem { get; set; }
        protected ISelectionAdapter SelectionAdapter { get; set; }
        public string Text { get; set; }
        public Style TextBoxStyle { get; set; }
        public AutoCompleteFilterPredicate`1<string> TextFilter { get; set; }
        public Binding ValueMemberBinding { get; set; }
        public string ValueMemberPath { get; set; }
        protected override Size ArrangeOverride(Size finalSize);
        protected virtual string FormatValue(object value);
        protected virtual ISelectionAdapter GetSelectionAdapterPart();
        protected bool HasFocus();
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        protected virtual void OnDropDownClosed(RoutedPropertyChangedEventArgs`1<bool> e);
        protected virtual void OnDropDownClosing(RoutedPropertyChangingEventArgs`1<bool> e);
        protected virtual void OnDropDownOpened(RoutedPropertyChangedEventArgs`1<bool> e);
        protected virtual void OnDropDownOpening(RoutedPropertyChangingEventArgs`1<bool> e);
        protected override void OnGotFocus(RoutedEventArgs e);
        protected override void OnKeyDown(KeyEventArgs e);
        protected override void OnLostFocus(RoutedEventArgs e);
        protected virtual void OnPopulated(PopulatedEventArgs e);
        protected virtual void OnPopulating(PopulatingEventArgs e);
        protected virtual void OnSelectionChanged(SelectionChangedEventArgs e);
        protected virtual void OnTextChanged(RoutedEventArgs e);
        public void PopulateComplete();
        public event RoutedPropertyChangedEventHandler`1<bool> DropDownClosed;
        public event RoutedPropertyChangingEventHandler`1<bool> DropDownClosing;
        public event RoutedPropertyChangedEventHandler`1<bool> DropDownOpened;
        public event RoutedPropertyChangingEventHandler`1<bool> DropDownOpening;
        public event PopulatedEventHandler Populated;
        public event PopulatingEventHandler Populating;
        public event SelectionChangedEventHandler SelectionChanged;
        public event RoutedEventHandler TextChanged;
    }

    public interface ISelectionAdapter
    {
        public IEnumerable ItemsSource { get; set; }
        public object SelectedItem { get; set; }
        public AutomationPeer CreateAutomationPeer();
        public void HandleKeyDown(KeyEventArgs e);
        public event RoutedEventHandler Cancel;
        public event RoutedEventHandler Commit;
        public event SelectionChangedEventHandler SelectionChanged;
    }

    public class SelectorSelectionAdapter: ISelectionAdapter
    {
        public SelectorSelectionAdapter();
        public SelectorSelectionAdapter(Selector selector);
        public IEnumerable ItemsSource { get; set; }
        public object SelectedItem { get; set; }
        public Selector SelectorControl { get; set; }
        public AutomationPeer CreateAutomationPeer();
        public void HandleKeyDown(KeyEventArgs e);
        protected virtual void OnCancel();
        protected virtual void OnCommit();
        protected void SelectedIndexDecrement();
        protected void SelectedIndexIncrement();
        public event RoutedEventHandler Cancel;
        public event RoutedEventHandler Commit;
        public event SelectionChangedEventHandler SelectionChanged;
    }

    public enum AutoCompleteFilterMode
    {
        Contains,
        ContainsCaseSensitive,
        ContainsOrdinal,
        ContainsOrdinalCaseSensitive,
        Custom,
        Equals,
        EqualsCaseSensitive,
        EqualsOrdinal,
        EqualsOrdinalCaseSensitive,
        None,
        StartsWith,
        StartsWithCaseSensitive,
        StartsWithOrdinal,
        StartsWithOrdinalCaseSensitive,
    }

    public delegate bool AutoCompleteFilterPredicate`1<T>(string search, T item);

    public class PopulatedEventArgs: RoutedEventArgs
    {
        public PopulatedEventArgs(IEnumerable data);
        public IEnumerable Data { get; set; }
    }

    public delegate void PopulatedEventHandler(object sender, PopulatedEventArgs e);

    public class PopulatingEventArgs: RoutedEventArgs
    {
        public PopulatingEventArgs(string parameter);
        public bool Cancel { get; set; }
        public string Parameter { get; set; }
    }

    public delegate void PopulatingEventHandler(object sender, PopulatingEventArgs e);

} 

namespace System.Windows.Automation.Peers
{
    public class FrameAutomationPeer: FrameworkElementAutomationPeer
    {
        public FrameAutomationPeer(Frame owner);
        protected override AutomationControlType GetAutomationControlTypeCore();
        protected override string GetClassNameCore();
        protected override string GetNameCore();
    }

} 

namespace System.Windows.Controls
{
    [ContentPropertyAttribute(..)]
    [TemplatePartAttribute(..)]
    [TemplatePartAttribute(..)]
    public class Frame: ContentControl, INavigate
    {
        public Frame();
        public static readonly DependencyProperty CacheSizeProperty;
        public static readonly DependencyProperty CanGoBackProperty;
        public static readonly DependencyProperty CanGoForwardProperty;
        public static readonly DependencyProperty ContentLoaderProperty;
        public static readonly DependencyProperty CurrentSourceProperty;
        public static readonly DependencyProperty JournalOwnershipProperty;
        public static readonly DependencyProperty SourceProperty;
        public static readonly DependencyProperty UriMapperProperty;
        public int CacheSize { get; set; }
        public bool CanGoBack { get; set; }
        public bool CanGoForward { get; set; }
        public INavigationContentLoader ContentLoader { get; set; }
        public Uri CurrentSource { get; set; }
        public JournalOwnership JournalOwnership { get; set; }
        public Uri Source { get; set; }
        public UriMapperBase UriMapper { get; set; }
        public void GoBack();
        public void GoForward();
        public bool Navigate(Uri source);
        public override void OnApplyTemplate();
        protected override AutomationPeer OnCreateAutomationPeer();
        public void StopLoading();
        public event FragmentNavigationEventHandler FragmentNavigation;
        public event NavigatedEventHandler Navigated;
        public event NavigatingCancelEventHandler Navigating;
        public event NavigationFailedEventHandler NavigationFailed;
        public event NavigationStoppedEventHandler NavigationStopped;
    }

    [ContentPropertyAttribute(..)]
    public class Page: UserControl
    {
        public Page();
        public NavigationCacheMode NavigationCacheMode { get; set; }
        public NavigationContext NavigationContext { get; }
        public NavigationService NavigationService { get; }
        public string Title { get; set; }
        protected virtual void OnFragmentNavigation(FragmentNavigationEventArgs e);
        protected virtual void OnNavigatedFrom(NavigationEventArgs e);
        protected virtual void OnNavigatedTo(NavigationEventArgs e);
        protected virtual void OnNavigatingFrom(NavigatingCancelEventArgs e);
    }

} 

namespace System.Windows.Navigation
{
    public interface INavigationContentLoader
    {
        public IAsyncResult BeginLoad(Uri targetUri, Uri currentUri, AsyncCallback userCallback, object asyncState);
        public void CancelLoad(IAsyncResult asyncResult);
        public bool CanLoad(Uri targetUri, Uri currentUri);
        public LoadResult EndLoad(IAsyncResult asyncResult);
    }

    public class LoadResult
    {
        public LoadResult(object loadedContent);
        public LoadResult(Uri redirectUri);
        public object LoadedContent { get; set; }
        public Uri RedirectUri { get; set; }
    }

    public sealed class NavigationContext
    {
        public IDictionary`2<string,string> QueryString { get; set; }
    }

    public sealed class NavigationService
    {
        public bool CanGoBack { get; }
        public bool CanGoForward { get; }
        public Uri CurrentSource { get; set; }
        public Uri Source { get; set; }
        public void GoBack();
        public void GoForward();
        public bool Navigate(Uri source);
        public void StopLoading();
        public event FragmentNavigationEventHandler FragmentNavigation;
        public event NavigatedEventHandler Navigated;
        public event NavigatingCancelEventHandler Navigating;
        public event NavigationFailedEventHandler NavigationFailed;
        public event NavigationStoppedEventHandler NavigationStopped;
    }

    public sealed class PageResourceContentLoader: INavigationContentLoader
    {
        public PageResourceContentLoader();
        public IAsyncResult BeginLoad(Uri targetUri, Uri currentUri, AsyncCallback userCallback, object asyncState);
        public void CancelLoad(IAsyncResult asyncResult);
        public bool CanLoad(Uri targetUri, Uri currentUri);
        public LoadResult EndLoad(IAsyncResult asyncResult);
    }

    [ContentPropertyAttribute(..)]
    public sealed class UriMapper: UriMapperBase
    {
        public UriMapper();
        public Collection`1<UriMapping> UriMappings { get; set; }
        public override Uri MapUri(Uri uri);
    }

    public abstract class UriMapperBase
    {
        protected UriMapperBase();
        public abstract Uri MapUri(Uri uri);
    }

    public sealed class UriMapping
    {
        public UriMapping();
        public Uri MappedUri { get; set; }
        public Uri Uri { get; set; }
        public Uri MapUri(Uri uri);
    }

    public enum JournalOwnership
    {
        Automatic,
        OwnsJournal,
        UsesParentJournal,
    }

    public enum NavigationCacheMode
    {
        Disabled,
        Enabled,
        Required,
    }

    public enum NavigationMode
    {
        Back,
        Forward,
        New,
    }

    public sealed class FragmentNavigationEventArgs: EventArgs
    {
        public string Fragment { get; }
    }

    public delegate void FragmentNavigationEventHandler(object sender, FragmentNavigationEventArgs e);

    public delegate void NavigatedEventHandler(object sender, NavigationEventArgs e);

    public sealed class NavigatingCancelEventArgs: CancelEventArgs
    {
        public NavigationMode NavigationMode { get; set; }
        public Uri Uri { get; set; }
    }

    public delegate void NavigatingCancelEventHandler(object sender, NavigatingCancelEventArgs e);

    public sealed class NavigationEventArgs: EventArgs
    {
        public object Content { get; set; }
        public Uri Uri { get; set; }
    }

    public sealed class NavigationFailedEventArgs: EventArgs
    {
        public Exception Exception { get; set; }
        public bool Handled { get; set; }
        public Uri Uri { get; set; }
    }

    public delegate void NavigationFailedEventHandler(object sender, NavigationFailedEventArgs e);

    public delegate void NavigationStoppedEventHandler(object sender, NavigationEventArgs e);

} 

namespace System.Xml.Linq
{
    [ExtensionAttribute(..)]
    public abstract sealed class Extensions
    {
        public static IEnumerable`1<XElement> Ancestors<T>(IEnumerable`1<T> source);
        public static IEnumerable`1<XElement> Ancestors<T>(IEnumerable`1<T> source, XName name);
        public static IEnumerable`1<XElement> AncestorsAndSelf(IEnumerable`1<XElement> source);
        public static IEnumerable`1<XElement> AncestorsAndSelf(IEnumerable`1<XElement> source, XName name);
        public static IEnumerable`1<XAttribute> Attributes(IEnumerable`1<XElement> source);
        public static IEnumerable`1<XAttribute> Attributes(IEnumerable`1<XElement> source, XName name);
        public static IEnumerable`1<XNode> DescendantNodes<T>(IEnumerable`1<T> source);
        public static IEnumerable`1<XNode> DescendantNodesAndSelf(IEnumerable`1<XElement> source);
        public static IEnumerable`1<XElement> Descendants<T>(IEnumerable`1<T> source);
        public static IEnumerable`1<XElement> Descendants<T>(IEnumerable`1<T> source, XName name);
        public static IEnumerable`1<XElement> DescendantsAndSelf(IEnumerable`1<XElement> source);
        public static IEnumerable`1<XElement> DescendantsAndSelf(IEnumerable`1<XElement> source, XName name);
        public static IEnumerable`1<XElement> Elements<T>(IEnumerable`1<T> source);
        public static IEnumerable`1<XElement> Elements<T>(IEnumerable`1<T> source, XName name);
        public static IEnumerable`1<T> InDocumentOrder<T>(IEnumerable`1<T> source);
        public static IEnumerable`1<XNode> Nodes<T>(IEnumerable`1<T> source);
        public static void Remove<T>(IEnumerable`1<T> source);
        public static void Remove(IEnumerable`1<XAttribute> source);
    }

    public class XAttribute: XObject, IXmlLineInfo
    {
        public XAttribute(XAttribute other);
        public XAttribute(XName name, object value);
        public static IEnumerable`1<XAttribute> EmptySequence { get; }
        public bool IsNamespaceDeclaration { get; }
        public XName Name { get; }
        public XAttribute NextAttribute { get; }
        public XAttribute PreviousAttribute { get; }
        public string Value { get; set; }
        public void Remove();
        public void SetValue(object value);
        public override string ToString();
        public static explicit operator bool(XAttribute attribute);
        public static explicit operator DateTime(XAttribute attribute);
        public static explicit operator DateTimeOffset(XAttribute attribute);
        public static explicit operator decimal(XAttribute attribute);
        public static explicit operator double(XAttribute attribute);
        public static explicit operator float(XAttribute attribute);
        public static explicit operator Guid(XAttribute attribute);
        public static explicit operator int(XAttribute attribute);
        public static explicit operator long(XAttribute attribute);
        public static explicit operator Nullable`1<ulong>(XAttribute attribute);
        public static explicit operator Nullable`1<float>(XAttribute attribute);
        public static explicit operator Nullable`1<bool>(XAttribute attribute);
        public static explicit operator Nullable`1<int>(XAttribute attribute);
        public static explicit operator Nullable`1<uint>(XAttribute attribute);
        public static explicit operator Nullable`1<long>(XAttribute attribute);
        public static explicit operator Nullable`1<decimal>(XAttribute attribute);
        public static explicit operator Nullable`1<double>(XAttribute attribute);
        public static explicit operator Nullable`1<TimeSpan>(XAttribute attribute);
        public static explicit operator Nullable`1<Guid>(XAttribute attribute);
        public static explicit operator Nullable`1<DateTime>(XAttribute attribute);
        public static explicit operator Nullable`1<DateTimeOffset>(XAttribute attribute);
        public static explicit operator string(XAttribute attribute);
        public static explicit operator TimeSpan(XAttribute attribute);
        public static explicit operator uint(XAttribute attribute);
        public static explicit operator ulong(XAttribute attribute);
    }

    public class XCData: XText, IXmlLineInfo
    {
        public XCData(string value);
        public XCData(XCData other);
        public override void WriteTo(XmlWriter writer);
    }

    public class XComment: XNode, IXmlLineInfo
    {
        public XComment(string value);
        public XComment(XComment other);
        public string Value { get; set; }
        public override void WriteTo(XmlWriter writer);
    }

    public abstract class XContainer: XNode, IXmlLineInfo
    {
        public XNode FirstNode { get; }
        public XNode LastNode { get; }
        public void Add(object content);
        public void Add(params object[] content);
        public void AddFirst(object content);
        public void AddFirst(params object[] content);
        public XmlWriter CreateWriter();
        public IEnumerable`1<XNode> DescendantNodes();
        public IEnumerable`1<XElement> Descendants();
        public IEnumerable`1<XElement> Descendants(XName name);
        public XElement Element(XName name);
        public IEnumerable`1<XElement> Elements();
        public IEnumerable`1<XElement> Elements(XName name);
        public IEnumerable`1<XNode> Nodes();
        public void RemoveNodes();
        public void ReplaceNodes(object content);
        public void ReplaceNodes(params object[] content);
    }

    public class XDeclaration
    {
        public XDeclaration(string version, string encoding, string standalone);
        public XDeclaration(XDeclaration other);
        public string Encoding { get; set; }
        public string Standalone { get; set; }
        public string Version { get; set; }
        public override string ToString();
    }

    public class XDocument: XContainer, IXmlLineInfo
    {
        public XDocument();
        public XDocument(params object[] content);
        public XDocument(XDeclaration declaration, params object[] content);
        public XDocument(XDocument other);
        public XDeclaration Declaration { get; set; }
        public XDocumentType DocumentType { get; }
        public XElement Root { get; }
        public static XDocument Load(Stream stream);
        public static XDocument Load(Stream stream, LoadOptions options);
        public static XDocument Load(string uri);
        public static XDocument Load(string uri, LoadOptions options);
        public static XDocument Load(TextReader textReader);
        public static XDocument Load(TextReader textReader, LoadOptions options);
        public static XDocument Load(XmlReader reader);
        public static XDocument Load(XmlReader reader, LoadOptions options);
        public static XDocument Parse(string text);
        public static XDocument Parse(string text, LoadOptions options);
        public void Save(Stream stream);
        public void Save(Stream stream, SaveOptions options);
        public void Save(TextWriter textWriter);
        public void Save(TextWriter textWriter, SaveOptions options);
        public void Save(XmlWriter writer);
        public override void WriteTo(XmlWriter writer);
    }

    public class XDocumentType: XNode, IXmlLineInfo
    {
        public XDocumentType(string name, string publicId, string systemId, string internalSubset);
        public XDocumentType(XDocumentType other);
        public string InternalSubset { get; set; }
        public string Name { get; set; }
        public string PublicId { get; set; }
        public string SystemId { get; set; }
        public override void WriteTo(XmlWriter writer);
    }

    [XmlSchemaProviderAttribute(..)]
    public class XElement: XContainer, IXmlLineInfo, IXmlSerializable
    {
        public XElement(XElement other);
        public XElement(XName name);
        public XElement(XName name, object content);
        public XElement(XName name, params object[] content);
        public XElement(XStreamingElement other);
        public static IEnumerable`1<XElement> EmptySequence { get; }
        public XAttribute FirstAttribute { get; }
        public bool HasAttributes { get; }
        public bool HasElements { get; }
        public bool IsEmpty { get; }
        public XAttribute LastAttribute { get; }
        public XName Name { get; set; }
        public string Value { get; set; }
        public IEnumerable`1<XElement> AncestorsAndSelf();
        public IEnumerable`1<XElement> AncestorsAndSelf(XName name);
        public XAttribute Attribute(XName name);
        public IEnumerable`1<XAttribute> Attributes();
        public IEnumerable`1<XAttribute> Attributes(XName name);
        public IEnumerable`1<XNode> DescendantNodesAndSelf();
        public IEnumerable`1<XElement> DescendantsAndSelf();
        public IEnumerable`1<XElement> DescendantsAndSelf(XName name);
        public XNamespace GetDefaultNamespace();
        public XNamespace GetNamespaceOfPrefix(string prefix);
        public string GetPrefixOfNamespace(XNamespace ns);
        public static XElement Load(Stream stream);
        public static XElement Load(Stream stream, LoadOptions options);
        public static XElement Load(string uri);
        public static XElement Load(string uri, LoadOptions options);
        public static XElement Load(TextReader textReader);
        public static XElement Load(TextReader textReader, LoadOptions options);
        public static XElement Load(XmlReader reader);
        public static XElement Load(XmlReader reader, LoadOptions options);
        public static XElement Parse(string text);
        public static XElement Parse(string text, LoadOptions options);
        public void RemoveAll();
        public void RemoveAttributes();
        public void ReplaceAll(object content);
        public void ReplaceAll(params object[] content);
        public void ReplaceAttributes(object content);
        public void ReplaceAttributes(params object[] content);
        public void Save(Stream stream);
        public void Save(Stream stream, SaveOptions options);
        public void Save(TextWriter textWriter);
        public void Save(TextWriter textWriter, SaveOptions options);
        public void Save(XmlWriter writer);
        public void SetAttributeValue(XName name, object value);
        public void SetElementValue(XName name, object value);
        public void SetValue(object value);
        public override void WriteTo(XmlWriter writer);
        public static explicit operator bool(XElement element);
        public static explicit operator DateTime(XElement element);
        public static explicit operator DateTimeOffset(XElement element);
        public static explicit operator decimal(XElement element);
        public static explicit operator double(XElement element);
        public static explicit operator float(XElement element);
        public static explicit operator Guid(XElement element);
        public static explicit operator int(XElement element);
        public static explicit operator long(XElement element);
        public static explicit operator Nullable`1<bool>(XElement element);
        public static explicit operator Nullable`1<uint>(XElement element);
        public static explicit operator Nullable`1<int>(XElement element);
        public static explicit operator Nullable`1<decimal>(XElement element);
        public static explicit operator Nullable`1<double>(XElement element);
        public static explicit operator Nullable`1<Guid>(XElement element);
        public static explicit operator Nullable`1<DateTimeOffset>(XElement element);
        public static explicit operator Nullable`1<TimeSpan>(XElement element);
        public static explicit operator Nullable`1<DateTime>(XElement element);
        public static explicit operator Nullable`1<ulong>(XElement element);
        public static explicit operator Nullable`1<float>(XElement element);
        public static explicit operator Nullable`1<long>(XElement element);
        public static explicit operator string(XElement element);
        public static explicit operator TimeSpan(XElement element);
        public static explicit operator uint(XElement element);
        public static explicit operator ulong(XElement element);
    }

    public sealed class XName: IEquatable`1
    {
        public string LocalName { get; }
        public XNamespace Namespace { get; }
        public string NamespaceName { get; }
        public override bool Equals(object obj);
        public static XName Get(string expandedName);
        public static XName Get(string localName, string namespaceName);
        public override int GetHashCode();
        public override string ToString();
        public static bool operator ==(XName left, XName right);
        public static bool operator !=(XName left, XName right);
        public static implicit operator XName(string expandedName);
    }

    public sealed class XNamespace
    {
        public string NamespaceName { get; }
        public static XNamespace None { get; }
        public static XNamespace Xml { get; }
        public static XNamespace Xmlns { get; }
        public override bool Equals(object obj);
        public static XNamespace Get(string namespaceName);
        public override int GetHashCode();
        public XName GetName(string localName);
        public override string ToString();
        public static XName operator +(XNamespace ns, string localName);
        public static bool operator ==(XNamespace left, XNamespace right);
        public static bool operator !=(XNamespace left, XNamespace right);
        public static implicit operator XNamespace(string namespaceName);
    }

    public abstract class XNode: XObject, IXmlLineInfo
    {
        public static XNodeDocumentOrderComparer DocumentOrderComparer { get; }
        public static XNodeEqualityComparer EqualityComparer { get; }
        public XNode NextNode { get; }
        public XNode PreviousNode { get; }
        public void AddAfterSelf(object content);
        public void AddAfterSelf(params object[] content);
        public void AddBeforeSelf(object content);
        public void AddBeforeSelf(params object[] content);
        public IEnumerable`1<XElement> Ancestors();
        public IEnumerable`1<XElement> Ancestors(XName name);
        public static int CompareDocumentOrder(XNode n1, XNode n2);
        public XmlReader CreateReader();
        public XmlReader CreateReader(ReaderOptions readerOptions);
        public static bool DeepEquals(XNode n1, XNode n2);
        public IEnumerable`1<XElement> ElementsAfterSelf();
        public IEnumerable`1<XElement> ElementsAfterSelf(XName name);
        public IEnumerable`1<XElement> ElementsBeforeSelf();
        public IEnumerable`1<XElement> ElementsBeforeSelf(XName name);
        public bool IsAfter(XNode node);
        public bool IsBefore(XNode node);
        public IEnumerable`1<XNode> NodesAfterSelf();
        public IEnumerable`1<XNode> NodesBeforeSelf();
        public static XNode ReadFrom(XmlReader reader);
        public void Remove();
        public void ReplaceWith(object content);
        public void ReplaceWith(params object[] content);
        public override string ToString();
        public string ToString(SaveOptions options);
        public abstract void WriteTo(XmlWriter writer);
    }

    public sealed class XNodeDocumentOrderComparer: IComparer`1
    {
        public XNodeDocumentOrderComparer();
        public int Compare(XNode x, XNode y);
    }

    public sealed class XNodeEqualityComparer: IEqualityComparer`1
    {
        public XNodeEqualityComparer();
        public bool Equals(XNode x, XNode y);
        public int GetHashCode(XNode obj);
    }

    public abstract class XObject: IXmlLineInfo
    {
        public string BaseUri { get; }
        public XDocument Document { get; }
        public abstract XmlNodeType NodeType { get; }
        public XElement Parent { get; }
        public void AddAnnotation(object annotation);
        public T Annotation<T>();
        public object Annotation(Type type);
        public IEnumerable`1<T> Annotations<T>();
        public IEnumerable`1<object> Annotations(Type type);
        public void RemoveAnnotations<T>();
        public void RemoveAnnotations(Type type);
        public event EventHandler`1<XObjectChangeEventArgs> Changed;
        public event EventHandler`1<XObjectChangeEventArgs> Changing;
    }

    public class XProcessingInstruction: XNode, IXmlLineInfo
    {
        public XProcessingInstruction(string target, string data);
        public XProcessingInstruction(XProcessingInstruction other);
        public string Data { get; set; }
        public string Target { get; set; }
        public override void WriteTo(XmlWriter writer);
    }

    public class XStreamingElement
    {
        public XStreamingElement(XName name);
        public XStreamingElement(XName name, object content);
        public XStreamingElement(XName name, params object[] content);
        public XName Name { get; set; }
        public void Add(object content);
        public void Add(params object[] content);
        public void Save(Stream stream);
        public void Save(Stream stream, SaveOptions options);
        public void Save(TextWriter textWriter);
        public void Save(TextWriter textWriter, SaveOptions options);
        public void Save(XmlWriter writer);
        public override string ToString();
        public string ToString(SaveOptions options);
        public void WriteTo(XmlWriter writer);
    }

    public class XText: XNode, IXmlLineInfo
    {
        public XText(string value);
        public XText(XText other);
        public string Value { get; set; }
        public override void WriteTo(XmlWriter writer);
    }

    [FlagsAttribute(..)]
    public enum LoadOptions
    {
        None,
        PreserveWhitespace,
        SetBaseUri,
        SetLineInfo,
    }

    [FlagsAttribute(..)]
    public enum ReaderOptions
    {
        None,
        OmitDuplicateNamespaces,
    }

    [FlagsAttribute(..)]
    public enum SaveOptions
    {
        DisableFormatting,
        None,
        OmitDuplicateNamespaces,
    }

    public enum XObjectChange
    {
        Add,
        Name,
        Remove,
        Value,
    }

    public class XObjectChangeEventArgs: EventArgs
    {
        public XObjectChangeEventArgs(XObjectChange objectChange);
        public static readonly XObjectChangeEventArgs Add;
        public static readonly XObjectChangeEventArgs Name;
        public static readonly XObjectChangeEventArgs Remove;
        public static readonly XObjectChangeEventArgs Value;
        public XObjectChange ObjectChange { get; }
    }

} 

namespace System.ServiceModel
{
    [AttributeUsageAttribute(..)]
    public sealed class XmlSerializerFormatAttribute: Attribute, _Attribute
    {
        public XmlSerializerFormatAttribute();
        public OperationFormatStyle Style { get; set; }
        public bool SupportFaults { get; set; }
    }

} 

namespace System.Xml.Serialization
{
    [DefaultMemberAttribute(..)]
    public class XmlAttributeOverrides
    {
        public XmlAttributeOverrides();
        public XmlAttributes this[Type type] { get; }
        public XmlAttributes this[Type type, string member] { get; }
        public void Add(Type type, string member, XmlAttributes attributes);
        public void Add(Type type, XmlAttributes attributes);
    }

    public class XmlAttributes
    {
        public XmlAttributes();
        public XmlAttributes(ICustomAttributeProvider provider);
        public XmlAnyElementAttributes XmlAnyElements { get; }
        public XmlArrayAttribute XmlArray { get; set; }
        public XmlArrayItemAttributes XmlArrayItems { get; }
        public XmlAttributeAttribute XmlAttribute { get; set; }
        public XmlChoiceIdentifierAttribute XmlChoiceIdentifier { get; }
        public object XmlDefaultValue { get; set; }
        public XmlElementAttributes XmlElements { get; }
        public XmlEnumAttribute XmlEnum { get; set; }
        public bool XmlIgnore { get; set; }
        public bool Xmlns { get; set; }
        public XmlRootAttribute XmlRoot { get; set; }
        public XmlTextAttribute XmlText { get; set; }
        public XmlTypeAttribute XmlType { get; set; }
    }

    public abstract class XmlMapping
    {
        public string ElementName { get; }
        public string Namespace { get; }
        public string XsdElementName { get; }
        public void SetKey(string key);
    }

    public class XmlMemberMapping
    {
        public bool Any { get; }
        public bool CheckSpecified { get; }
        public string ElementName { get; }
        public string MemberName { get; }
        public string Namespace { get; }
        public string TypeFullName { get; }
        public string TypeName { get; }
        public string TypeNamespace { get; }
        public string XsdElementName { get; }
    }

    [DefaultMemberAttribute(..)]
    public class XmlMembersMapping: XmlMapping
    {
        public int Count { get; }
        public string TypeName { get; }
        public string TypeNamespace { get; }
        public XmlMemberMapping this[int index] { get; }
    }

    public class XmlReflectionImporter
    {
        public XmlReflectionImporter();
        public XmlReflectionImporter(string defaultNamespace);
        public XmlReflectionImporter(XmlAttributeOverrides attributeOverrides);
        public XmlReflectionImporter(XmlAttributeOverrides attributeOverrides, string defaultNamespace);
        public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement);
        public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool rpc);
        public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool rpc, bool openModel);
        public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool rpc, bool openModel, XmlMappingAccess access);
        public XmlTypeMapping ImportTypeMapping(Type type);
        public XmlTypeMapping ImportTypeMapping(Type type, string defaultNamespace);
        public XmlTypeMapping ImportTypeMapping(Type type, XmlRootAttribute root);
        public XmlTypeMapping ImportTypeMapping(Type type, XmlRootAttribute root, string defaultNamespace);
        public void IncludeType(Type type);
        public void IncludeTypes(ICustomAttributeProvider provider);
    }

    public class XmlReflectionMember
    {
        public XmlReflectionMember();
        public bool IsReturnValue { get; set; }
        public string MemberName { get; set; }
        public Type MemberType { get; set; }
        public bool OverrideIsNullable { get; set; }
        public XmlAttributes XmlAttributes { get; set; }
    }

    public abstract class XmlSerializationGeneratedCode
    {
        protected XmlSerializationGeneratedCode();
    }

    public abstract class XmlSerializationReader: XmlSerializationGeneratedCode
    {
        protected XmlSerializationReader();
        protected bool DecodeName { get; set; }
        protected bool IsReturnValue { get; set; }
        protected XmlReader Reader { get; }
        protected int ReaderCount { get; }
        protected void CheckReaderCount(ref int whileIterations, ref int readerCount);
        protected string CollapseWhitespace(string value);
        protected Exception CreateAbstractTypeException(string name, string ns);
        protected Exception CreateBadDerivationException(string xsdDerived, string nsDerived, string xsdBase, string nsBase, string clrDerived, string clrBase);
        protected Exception CreateCtorHasSecurityException(string typeName);
        protected Exception CreateInaccessibleConstructorException(string typeName);
        protected Exception CreateInvalidCastException(Type type, object value);
        protected Exception CreateInvalidCastException(Type type, object value, string id);
        protected Exception CreateMissingIXmlSerializableType(string name, string ns, string clrType);
        protected Exception CreateReadOnlyCollectionException(string name);
        protected Exception CreateUnknownConstantException(string value, Type enumType);
        protected Exception CreateUnknownNodeException();
        protected Exception CreateUnknownTypeException(XmlQualifiedName type);
        protected Array EnsureArrayIndex(Array a, int index, Type elementType);
        protected bool GetNullAttr();
        protected XmlQualifiedName GetXsiType();
        protected abstract void InitCallbacks();
        protected abstract void InitIDs();
        protected bool IsXmlnsAttribute(string name);
        protected XmlQualifiedName ReadElementQualifiedName();
        protected void ReadEndElement();
        protected bool ReadNull();
        protected XmlQualifiedName ReadNullableQualifiedName();
        protected string ReadNullableString();
        protected IXmlSerializable ReadSerializable(IXmlSerializable serializable);
        protected IXmlSerializable ReadSerializable(IXmlSerializable serializable, bool wrappedAny);
        protected string ReadString(string value);
        protected string ReadString(string value, bool trim);
        protected object ReadTypedNull(XmlQualifiedName type);
        protected object ReadTypedPrimitive(XmlQualifiedName type);
        protected Array ShrinkArray(Array a, int length, Type elementType, bool isNullable);
        protected byte[] ToByteArrayBase64(bool isNull);
        protected static byte[] ToByteArrayBase64(string value);
        protected byte[] ToByteArrayHex(bool isNull);
        protected static byte[] ToByteArrayHex(string value);
        protected static char ToChar(string value);
        protected static DateTime ToDate(string value);
        protected static DateTime ToDateTime(string value);
        protected static long ToEnum(string value, IDictionary h, string typeName);
        protected static DateTime ToTime(string value);
        protected static string ToXmlName(string value);
        protected static string ToXmlNCName(string value);
        protected static string ToXmlNmToken(string value);
        protected static string ToXmlNmTokens(string value);
        protected XmlQualifiedName ToXmlQualifiedName(string value);
        protected void UnknownNode(object o);
        protected void UnknownNode(object o, string qnames);
    }

    public abstract class XmlSerializationWriter: XmlSerializationGeneratedCode
    {
        protected XmlSerializationWriter();
        protected bool EscapeName { get; set; }
        protected XmlWriter Writer { get; set; }
        protected IList XmlNamespaces { get; set; }
        protected Exception CreateChoiceIdentifierValueException(string value, string identifier, string name, string ns);
        protected Exception CreateInvalidAnyTypeException(object o);
        protected Exception CreateInvalidAnyTypeException(Type type);
        protected Exception CreateInvalidChoiceIdentifierValueException(string type, string identifier);
        protected Exception CreateInvalidEnumValueException(object value, string typeName);
        protected Exception CreateMismatchChoiceException(string value, string elementName, string enumValue);
        protected Exception CreateUnknownAnyElementException(string name, string ns);
        protected Exception CreateUnknownTypeException(object o);
        protected Exception CreateUnknownTypeException(Type type);
        protected static byte[] FromByteArrayBase64(byte[] value);
        protected static string FromByteArrayHex(byte[] value);
        protected static string FromChar(char value);
        protected static string FromDate(DateTime value);
        protected static string FromDateTime(DateTime value);
        protected static string FromEnum(long value, string[] values, long[] ids);
        protected static string FromEnum(long value, string[] values, long[] ids, string typeName);
        protected static string FromTime(DateTime value);
        protected static string FromXmlName(string name);
        protected static string FromXmlNCName(string ncName);
        protected static string FromXmlNmToken(string nmToken);
        protected static string FromXmlNmTokens(string nmTokens);
        protected string FromXmlQualifiedName(XmlQualifiedName xmlQualifiedName);
        protected string FromXmlQualifiedName(XmlQualifiedName xmlQualifiedName, bool ignoreEmpty);
        protected abstract void InitCallbacks();
        protected void TopLevelElement();
        protected void WriteAttribute(string localName, byte[] value);
        protected void WriteAttribute(string localName, string value);
        protected void WriteAttribute(string localName, string ns, byte[] value);
        protected void WriteAttribute(string localName, string ns, string value);
        protected void WriteAttribute(string prefix, string localName, string ns, string value);
        protected void WriteElementQualifiedName(string localName, string ns, XmlQualifiedName value);
        protected void WriteElementQualifiedName(string localName, string ns, XmlQualifiedName value, XmlQualifiedName xsiType);
        protected void WriteElementQualifiedName(string localName, XmlQualifiedName value);
        protected void WriteElementQualifiedName(string localName, XmlQualifiedName value, XmlQualifiedName xsiType);
        protected void WriteElementString(string localName, string value);
        protected void WriteElementString(string localName, string ns, string value);
        protected void WriteElementString(string localName, string ns, string value, XmlQualifiedName xsiType);
        protected void WriteElementString(string localName, string value, XmlQualifiedName xsiType);
        protected void WriteElementStringRaw(string localName, byte[] value);
        protected void WriteElementStringRaw(string localName, byte[] value, XmlQualifiedName xsiType);
        protected void WriteElementStringRaw(string localName, string value);
        protected void WriteElementStringRaw(string localName, string ns, byte[] value);
        protected void WriteElementStringRaw(string localName, string ns, byte[] value, XmlQualifiedName xsiType);
        protected void WriteElementStringRaw(string localName, string ns, string value);
        protected void WriteElementStringRaw(string localName, string ns, string value, XmlQualifiedName xsiType);
        protected void WriteElementStringRaw(string localName, string value, XmlQualifiedName xsiType);
        protected void WriteEmptyTag(string name);
        protected void WriteEmptyTag(string name, string ns);
        protected void WriteEndElement();
        protected void WriteEndElement(object o);
        protected void WriteNamespaceDeclarations(XmlSerializerNamespaces xmlns);
        protected void WriteNullableQualifiedNameEncoded(string name, string ns, XmlQualifiedName value, XmlQualifiedName xsiType);
        protected void WriteNullableQualifiedNameLiteral(string name, string ns, XmlQualifiedName value);
        protected void WriteNullableStringEncoded(string name, string ns, string value, XmlQualifiedName xsiType);
        protected void WriteNullableStringEncodedRaw(string name, string ns, byte[] value, XmlQualifiedName xsiType);
        protected void WriteNullableStringEncodedRaw(string name, string ns, string value, XmlQualifiedName xsiType);
        protected void WriteNullableStringLiteral(string name, string ns, string value);
        protected void WriteNullableStringLiteralRaw(string name, string ns, byte[] value);
        protected void WriteNullableStringLiteralRaw(string name, string ns, string value);
        protected void WriteNullTagEncoded(string name);
        protected void WriteNullTagEncoded(string name, string ns);
        protected void WriteNullTagLiteral(string name);
        protected void WriteNullTagLiteral(string name, string ns);
        protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable);
        protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped);
        protected void WriteStartDocument();
        protected void WriteStartElement(string name);
        protected void WriteStartElement(string name, string ns);
        protected void WriteStartElement(string name, string ns, bool writePrefixed);
        protected void WriteStartElement(string name, string ns, object o);
        protected void WriteStartElement(string name, string ns, object o, bool writePrefixed);
        protected void WriteStartElement(string name, string ns, object o, bool writePrefixed, XmlSerializerNamespaces xmlns);
        protected void WriteTypedPrimitive(string name, string ns, object o, bool xsiType);
        protected void WriteValue(byte[] value);
        protected void WriteValue(string value);
        protected void WriteXsiType(string name, string ns);
    }

    public class XmlSerializer
    {
        protected XmlSerializer();
        public XmlSerializer(Type type);
        public XmlSerializer(Type type, string defaultNamespace);
        public XmlSerializer(Type type, Type[] extraTypes);
        public XmlSerializer(Type type, XmlAttributeOverrides overrides);
        public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace);
        public XmlSerializer(Type type, XmlRootAttribute root);
        public XmlSerializer(XmlTypeMapping xmlTypeMapping);
        public virtual bool CanDeserialize(XmlReader xmlReader);
        protected virtual XmlSerializationReader CreateReader();
        protected virtual XmlSerializationWriter CreateWriter();
        public object Deserialize(Stream stream);
        public object Deserialize(TextReader textReader);
        public object Deserialize(XmlReader xmlReader);
        protected virtual object Deserialize(XmlSerializationReader reader);
        public static XmlSerializer[] FromMappings(XmlMapping[] mappings);
        public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Type type);
        public static XmlSerializer[] FromTypes(Type[] types);
        protected virtual void Serialize(object o, XmlSerializationWriter writer);
        public void Serialize(Stream stream, object o);
        public void Serialize(Stream stream, object o, XmlSerializerNamespaces namespaces);
        public void Serialize(TextWriter textWriter, object o);
        public void Serialize(TextWriter textWriter, object o, XmlSerializerNamespaces namespaces);
        public void Serialize(XmlWriter xmlWriter, object o);
        public void Serialize(XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces);
    }

    public abstract class XmlSerializerImplementation
    {
        protected XmlSerializerImplementation();
        public virtual XmlSerializationReader Reader { get; }
        public virtual XmlSerializationWriter Writer { get; }
        public virtual IDictionary XmlReadMethods { get; }
        public virtual IDictionary XmlTypedSerializers { get; }
        public virtual IDictionary XmlWriteMethods { get; }
        public virtual bool CanSerialize(Type type);
        public virtual XmlSerializer GetSerializer(Type type);
    }

    public class XmlSerializerNamespaces
    {
        public XmlSerializerNamespaces();
        public XmlSerializerNamespaces(XmlQualifiedName[] namespaces);
        public XmlSerializerNamespaces(XmlSerializerNamespaces namespaces);
        public int Count { get; }
        public void Add(string prefix, string ns);
        public XmlQualifiedName[] ToArray();
    }

    public class XmlTypeMapping: XmlMapping
    {
        public string TypeFullName { get; }
        public string TypeName { get; }
        public string XsdTypeName { get; }
        public string XsdTypeNamespace { get; }
    }

    [FlagsAttribute(..)]
    public enum XmlMappingAccess
    {
        None,
        Read,
        Write,
    }

    [DefaultMemberAttribute(..)]
    public class XmlAnyElementAttributes: IList
    {
        public XmlAnyElementAttributes();
        public int Count { get; }
        public XmlAnyElementAttribute this[int index] { get; set; }
        public int Add(XmlAnyElementAttribute attribute);
        public void Clear();
        public bool Contains(XmlAnyElementAttribute attribute);
        public void CopyTo(XmlAnyElementAttribute[] array, int index);
        public IEnumerator GetEnumerator();
        public int IndexOf(XmlAnyElementAttribute attribute);
        public void Insert(int index, XmlAnyElementAttribute attribute);
        public void Remove(XmlAnyElementAttribute attribute);
        public void RemoveAt(int index);
    }

    [DefaultMemberAttribute(..)]
    public class XmlArrayItemAttributes: IList
    {
        public XmlArrayItemAttributes();
        public int Count { get; }
        public XmlArrayItemAttribute this[int index] { get; set; }
        public int Add(XmlArrayItemAttribute attribute);
        public void Clear();
        public bool Contains(XmlArrayItemAttribute attribute);
        public void CopyTo(XmlArrayItemAttribute[] array, int index);
        public IEnumerator GetEnumerator();
        public int IndexOf(XmlArrayItemAttribute attribute);
        public void Insert(int index, XmlArrayItemAttribute attribute);
        public void Remove(XmlArrayItemAttribute attribute);
        public void RemoveAt(int index);
    }

    [DefaultMemberAttribute(..)]
    public class XmlElementAttributes: IList
    {
        public XmlElementAttributes();
        public int Count { get; }
        public XmlElementAttribute this[int index] { get; set; }
        public int Add(XmlElementAttribute attribute);
        public void Clear();
        public bool Contains(XmlElementAttribute attribute);
        public void CopyTo(XmlElementAttribute[] array, int index);
        public IEnumerator GetEnumerator();
        public int IndexOf(XmlElementAttribute attribute);
        public void Insert(int index, XmlElementAttribute attribute);
        public void Remove(XmlElementAttribute attribute);
        public void RemoveAt(int index);
    }

    public delegate void XmlSerializationWriteCallback(object o);

} 

namespace System.Xml.Resolvers
{
    public class XmlPreloadedResolver: XmlResolver
    {
        public XmlPreloadedResolver();
        public XmlPreloadedResolver(XmlKnownDtds preloadedDtds);
        public XmlPreloadedResolver(XmlResolver fallbackResolver);
        public XmlPreloadedResolver(XmlResolver fallbackResolver, XmlKnownDtds preloadedDtds);
        public XmlPreloadedResolver(XmlResolver fallbackResolver, XmlKnownDtds preloadedDtds, IEqualityComparer`1<Uri> uriComparer);
        public IEnumerable`1<Uri> PreloadedUris { get; }
        public void Add(Uri uri, byte[] value);
        public void Add(Uri uri, byte[] value, int offset, int count);
        public void Add(Uri uri, Stream value);
        public void Add(Uri uri, string value);
        public override object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn);
        public void Remove(Uri uri);
        public override Uri ResolveUri(Uri baseUri, string relativeUri);
        public override bool SupportsType(Uri absoluteUri, Type type);
    }

    [FlagsAttribute(..)]
    public enum XmlKnownDtds
    {
        All,
        None,
        Rss091,
        Xhtml10,
    }

}