fxdac is a tool for refactoring framework reference assemblies

This is the initial commit

.gitignore

@@ -0,0 +1,257 @@
+syntax: glob
+
+### VisualStudio ###
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+*.dll
+project.lock.json
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+build/
+bld/
+[Bb]in/
+[Oo]bj/
+msbuild.log
+
+# Roslyn stuff
+*.sln.ide
+*.ide/
+.vs/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+#NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+*.cachefile
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding addin-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+*.pubxml
+*.publishproj
+
+# NuGet Packages
+*.nupkg
+**/packages/*
+
+# Windows Azure Build Output
+csx/
+*.build.csdef
+
+# Windows Store app package directory
+AppPackages/
+
+# Others
+sql/
+*.Cache
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+*.metaproj
+*.metaproj.tmp
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+### MonoDevelop ###
+
+*.pidb
+*.userprefs
+
+### Windows ###
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+### Linux ###
+
+*~
+
+# KDE directory preferences
+.directory
+
+### OSX ###
+
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+#dotnet.exe output
+tools/
+
+
+
+*.ncrunchproject
+*.ncrunchsolution
+
+#dotnet cli
+[Dd]otnet/
+
+# Nuget.exe
+nuget.exe
+
+# VS Code Files
+.vscode

fxdac/fxdac.sln

@@ -0,0 +1,27 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25123.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "fxdac", "fxdac\fxdac.csproj", "{70BD0983-796E-4F38-8593-E2523590F853}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{70BD0983-796E-4F38-8593-E2523590F853}.Debug|Any CPU.ActiveCfg = Debug|x86
+		{70BD0983-796E-4F38-8593-E2523590F853}.Debug|Any CPU.Build.0 = Debug|x86
+		{70BD0983-796E-4F38-8593-E2523590F853}.Debug|x86.ActiveCfg = Debug|x86
+		{70BD0983-796E-4F38-8593-E2523590F853}.Debug|x86.Build.0 = Debug|x86
+		{70BD0983-796E-4F38-8593-E2523590F853}.Release|Any CPU.ActiveCfg = Release|x86
+		{70BD0983-796E-4F38-8593-E2523590F853}.Release|x86.ActiveCfg = Release|x86
+		{70BD0983-796E-4F38-8593-E2523590F853}.Release|x86.Build.0 = Release|x86
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

fxdac/fxdac/Data/Contracts/Microsoft.Registry.cs

@@ -0,0 +1,15 @@
+[assembly:System.CLSCompliant(true)]
+namespace Microsoft.Win32 {
+  [System.FlagsAttribute]
+  public enum RegistryOptions {
+    None = 0,
+    Volatile = 1,
+  }
+
+  public enum RegistryView {
+    Default = 0,
+    Registry32 = 512,
+    Registry64 = 256,
+  }
+
+} // end of Microsoft.Win32

fxdac/fxdac/Data/Contracts/Microsoft.Win32.SafeHandles.cs

@@ -0,0 +1,25 @@
+[assembly:System.CLSCompliant(true)]
+namespace Microsoft.Win32.SafeHandles {
+  [System.Security.SecurityCriticalAttribute]
+  public abstract partial class CriticalHandleMinusOneIsInvalid : System.Runtime.InteropServices.CriticalHandle {
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    protected CriticalHandleMinusOneIsInvalid() : base (default(System.IntPtr)) { }
+    public override bool IsInvalid { [System.Security.SecurityCriticalAttribute]get { return default(bool); } }
+  }
+
+  [System.Security.SecurityCriticalAttribute]
+  public abstract partial class CriticalHandleZeroOrMinusOneIsInvalid : System.Runtime.InteropServices.CriticalHandle {
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    protected CriticalHandleZeroOrMinusOneIsInvalid() : base (default(System.IntPtr)) { }
+    public override bool IsInvalid { [System.Security.SecurityCriticalAttribute]get { return default(bool); } }
+  }
+
+  [System.Security.SecurityCriticalAttribute]
+  public sealed partial class SafeRegistryHandle : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid {
+    [System.Security.SecurityCriticalAttribute]
+    public SafeRegistryHandle(System.IntPtr preexistingHandle, bool ownsHandle) : base (default(bool)) { }
+    [System.Security.SecurityCriticalAttribute]
+    protected override bool ReleaseHandle() { return default(bool); }
+  }
+
+} // end of Microsoft.Win32.SafeHandles

fxdac/fxdac/Data/Contracts/System.CodeDom.cs

@@ -0,0 +1,46 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.CodeDom.Compiler {
+  public partial class IndentedTextWriter : System.IO.TextWriter {
+    public const string DefaultTabString = "    ";
+    public IndentedTextWriter(System.IO.TextWriter writer) { }
+    public IndentedTextWriter(System.IO.TextWriter writer, string tabString) { }
+    public override System.Text.Encoding Encoding { get { return default(System.Text.Encoding); } }
+    public int Indent { get { return default(int); } set { } }
+    public System.IO.TextWriter InnerWriter { get { return default(System.IO.TextWriter); } }
+    public override string NewLine { get { return default(string); } set { } }
+    public override void Close() { }
+    public override void Flush() { }
+    protected virtual void OutputTabs() { }
+    public override void Write(bool value) { }
+    public override void Write(char value) { }
+    public override void Write(char[] buffer) { }
+    public override void Write(char[] buffer, int index, int count) { }
+    public override void Write(double value) { }
+    public override void Write(int value) { }
+    public override void Write(long value) { }
+    public override void Write(object value) { }
+    public override void Write(float value) { }
+    public override void Write(string s) { }
+    public override void Write(string format, object arg0) { }
+    public override void Write(string format, object arg0, object arg1) { }
+    public override void Write(string format, params object[] arg) { }
+    public override void WriteLine() { }
+    public override void WriteLine(bool value) { }
+    public override void WriteLine(char value) { }
+    public override void WriteLine(char[] buffer) { }
+    public override void WriteLine(char[] buffer, int index, int count) { }
+    public override void WriteLine(double value) { }
+    public override void WriteLine(int value) { }
+    public override void WriteLine(long value) { }
+    public override void WriteLine(object value) { }
+    public override void WriteLine(float value) { }
+    public override void WriteLine(string s) { }
+    public override void WriteLine(string format, object arg0) { }
+    public override void WriteLine(string format, object arg0, object arg1) { }
+    public override void WriteLine(string format, params object[] arg) { }
+    [System.CLSCompliantAttribute(false)]
+    public override void WriteLine(uint value) { }
+    public void WriteLineNoTabs(string s) { }
+  }
+
+} // end of System.CodeDom.Compiler

fxdac/fxdac/Data/Contracts/System.Collections.Concurrent.cs

@@ -0,0 +1,211 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Collections.Concurrent {
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class ConcurrentDictionary<TKey, TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IDictionary<TKey, TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable {
+    public ConcurrentDictionary() { }
+    public ConcurrentDictionary(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> collection) { }
+    public ConcurrentDictionary(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> collection, System.Collections.Generic.IEqualityComparer<TKey> comparer) { }
+    public ConcurrentDictionary(System.Collections.Generic.IEqualityComparer<TKey> comparer) { }
+    public ConcurrentDictionary(int concurrencyLevel, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> collection, System.Collections.Generic.IEqualityComparer<TKey> comparer) { }
+    public ConcurrentDictionary(int concurrencyLevel, int capacity) { }
+    public ConcurrentDictionary(int concurrencyLevel, int capacity, System.Collections.Generic.IEqualityComparer<TKey> comparer) { }
+    public int Count { get { return default(int); } }
+    public bool IsEmpty { get { return default(bool); } }
+    public TValue this[TKey key] { get { return default(TValue); } set { } }
+    public System.Collections.Generic.ICollection<TKey> Keys { get { return default(System.Collections.Generic.ICollection<TKey>); } }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get { return default(bool); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    bool System.Collections.IDictionary.IsFixedSize { get { return default(bool); } }
+    bool System.Collections.IDictionary.IsReadOnly { get { return default(bool); } }
+    object System.Collections.IDictionary.this[object key] { get { return default(object); } set { } }
+    System.Collections.ICollection System.Collections.IDictionary.Keys { get { return default(System.Collections.ICollection); } }
+    System.Collections.ICollection System.Collections.IDictionary.Values { get { return default(System.Collections.ICollection); } }
+    public System.Collections.Generic.ICollection<TValue> Values { get { return default(System.Collections.Generic.ICollection<TValue>); } }
+    public TValue AddOrUpdate(TKey key, TValue addValue, System.Func<TKey, TValue, TValue> updateValueFactory) { return default(TValue); }
+    public TValue AddOrUpdate(TKey key, System.Func<TKey, TValue> addValueFactory, System.Func<TKey, TValue, TValue> updateValueFactory) { return default(TValue); }
+    public void Clear() { }
+    public bool ContainsKey(TKey key) { return default(bool); }
+    [System.Diagnostics.DebuggerHiddenAttribute]
+    public System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>); }
+    public TValue GetOrAdd(TKey key, TValue value) { return default(TValue); }
+    public TValue GetOrAdd(TKey key, System.Func<TKey, TValue> valueFactory) { return default(TValue); }
+    void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Contains(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { return default(bool); }
+    void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(System.Collections.Generic.KeyValuePair<TKey, TValue>[] array, int index) { }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { return default(bool); }
+    void System.Collections.Generic.IDictionary<TKey,TValue>.Add(TKey key, TValue value) { }
+    bool System.Collections.Generic.IDictionary<TKey,TValue>.Remove(TKey key) { return default(bool); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    void System.Collections.IDictionary.Add(object key, object value) { }
+    bool System.Collections.IDictionary.Contains(object key) { return default(bool); }
+    System.Collections.IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    void System.Collections.IDictionary.Remove(object key) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public System.Collections.Generic.KeyValuePair<TKey, TValue>[] ToArray() { return default(System.Collections.Generic.KeyValuePair<TKey, TValue>[]); }
+    public bool TryAdd(TKey key, TValue value) { return default(bool); }
+    public bool TryGetValue(TKey key, out TValue value) { value = default(TValue); return default(bool); }
+    public bool TryRemove(TKey key, out TValue value) { value = default(TValue); return default(bool); }
+    public bool TryUpdate(TKey key, TValue newValue, TValue comparisonValue) { return default(bool); }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class ConcurrentQueue<T> : System.Collections.Concurrent.IProducerConsumerCollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable {
+    public ConcurrentQueue() { }
+    public ConcurrentQueue(System.Collections.Generic.IEnumerable<T> collection) { }
+    public int Count { get { return default(int); } }
+    public bool IsEmpty { get { return default(bool); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public void CopyTo(T[] array, int index) { }
+    public void Enqueue(T item) { }
+    public System.Collections.Generic.IEnumerator<T> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    bool System.Collections.Concurrent.IProducerConsumerCollection<T>.TryAdd(T item) { return default(bool); }
+    bool System.Collections.Concurrent.IProducerConsumerCollection<T>.TryTake(out T item) { item = default(T); return default(bool); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public T[] ToArray() { return default(T[]); }
+    public bool TryDequeue(out T result) { result = default(T); return default(bool); }
+    public bool TryPeek(out T result) { result = default(T); return default(bool); }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  public partial class ConcurrentStack<T> : System.Collections.Concurrent.IProducerConsumerCollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable {
+    public ConcurrentStack() { }
+    public ConcurrentStack(System.Collections.Generic.IEnumerable<T> collection) { }
+    public int Count { get { return default(int); } }
+    public bool IsEmpty { get { return default(bool); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public void Clear() { }
+    public void CopyTo(T[] array, int index) { }
+    public System.Collections.Generic.IEnumerator<T> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    public void Push(T item) { }
+    public void PushRange(T[] items) { }
+    public void PushRange(T[] items, int startIndex, int count) { }
+    bool System.Collections.Concurrent.IProducerConsumerCollection<T>.TryAdd(T item) { return default(bool); }
+    bool System.Collections.Concurrent.IProducerConsumerCollection<T>.TryTake(out T item) { item = default(T); return default(bool); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public T[] ToArray() { return default(T[]); }
+    public bool TryPeek(out T result) { result = default(T); return default(bool); }
+    public bool TryPop(out T result) { result = default(T); return default(bool); }
+    public int TryPopRange(T[] items) { return default(int); }
+    public int TryPopRange(T[] items, int startIndex, int count) { return default(int); }
+  }
+
+  [System.FlagsAttribute]
+  public enum EnumerablePartitionerOptions {
+    NoBuffering = 1,
+    None = 0,
+  }
+
+  public partial interface IProducerConsumerCollection<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable {
+    void CopyTo(T[] array, int index);
+    T[] ToArray();
+    bool TryAdd(T item);
+    bool TryTake(out T item);
+  }
+
+  public abstract partial class OrderablePartitioner<TSource> : System.Collections.Concurrent.Partitioner<TSource> {
+    protected OrderablePartitioner(bool keysOrderedInEachPartition, bool keysOrderedAcrossPartitions, bool keysNormalized) { }
+    public bool KeysNormalized { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } }
+    public bool KeysOrderedAcrossPartitions { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } }
+    public bool KeysOrderedInEachPartition { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } }
+    public override System.Collections.Generic.IEnumerable<TSource> GetDynamicPartitions() { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public virtual System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<long, TSource>> GetOrderableDynamicPartitions() { return default(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<long, TSource>>); }
+    public abstract System.Collections.Generic.IList<System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<long, TSource>>> GetOrderablePartitions(int partitionCount);
+    public override System.Collections.Generic.IList<System.Collections.Generic.IEnumerator<TSource>> GetPartitions(int partitionCount) { return default(System.Collections.Generic.IList<System.Collections.Generic.IEnumerator<TSource>>); }
+  }
+
+  public static partial class Partitioner {
+    public static System.Collections.Concurrent.OrderablePartitioner<System.Tuple<int, int>> Create(int fromInclusive, int toExclusive) { return default(System.Collections.Concurrent.OrderablePartitioner<System.Tuple<int, int>>); }
+    public static System.Collections.Concurrent.OrderablePartitioner<System.Tuple<int, int>> Create(int fromInclusive, int toExclusive, int rangeSize) { return default(System.Collections.Concurrent.OrderablePartitioner<System.Tuple<int, int>>); }
+    public static System.Collections.Concurrent.OrderablePartitioner<System.Tuple<long, long>> Create(long fromInclusive, long toExclusive) { return default(System.Collections.Concurrent.OrderablePartitioner<System.Tuple<long, long>>); }
+    public static System.Collections.Concurrent.OrderablePartitioner<System.Tuple<long, long>> Create(long fromInclusive, long toExclusive, long rangeSize) { return default(System.Collections.Concurrent.OrderablePartitioner<System.Tuple<long, long>>); }
+    public static System.Collections.Concurrent.OrderablePartitioner<TSource> Create<TSource>(TSource[] array, bool loadBalance) { return default(System.Collections.Concurrent.OrderablePartitioner<TSource>); }
+    public static System.Collections.Concurrent.OrderablePartitioner<TSource> Create<TSource>(System.Collections.Generic.IEnumerable<TSource> source) { return default(System.Collections.Concurrent.OrderablePartitioner<TSource>); }
+    public static System.Collections.Concurrent.OrderablePartitioner<TSource> Create<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Collections.Concurrent.EnumerablePartitionerOptions partitionerOptions) { return default(System.Collections.Concurrent.OrderablePartitioner<TSource>); }
+    public static System.Collections.Concurrent.OrderablePartitioner<TSource> Create<TSource>(System.Collections.Generic.IList<TSource> list, bool loadBalance) { return default(System.Collections.Concurrent.OrderablePartitioner<TSource>); }
+  }
+
+  public abstract partial class Partitioner<TSource> {
+    protected Partitioner() { }
+    public virtual bool SupportsDynamicPartitions { get { return default(bool); } }
+    public virtual System.Collections.Generic.IEnumerable<TSource> GetDynamicPartitions() { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public abstract System.Collections.Generic.IList<System.Collections.Generic.IEnumerator<TSource>> GetPartitions(int partitionCount);
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}, Type = {m_collection}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class BlockingCollection<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.IDisposable {
+    public BlockingCollection() { }
+    public BlockingCollection(System.Collections.Concurrent.IProducerConsumerCollection<T> collection) { }
+    public BlockingCollection(System.Collections.Concurrent.IProducerConsumerCollection<T> collection, int boundedCapacity) { }
+    public BlockingCollection(int boundedCapacity) { }
+    public int BoundedCapacity { get { return default(int); } }
+    public int Count { get { return default(int); } }
+    public bool IsAddingCompleted { get { return default(bool); } }
+    public bool IsCompleted { get { return default(bool); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public void Add(T item) { }
+    public void Add(T item, System.Threading.CancellationToken cancellationToken) { }
+    public static int AddToAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, T item) { return default(int); }
+    public static int AddToAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, T item, System.Threading.CancellationToken cancellationToken) { return default(int); }
+    public void CompleteAdding() { }
+    public void CopyTo(T[] array, int index) { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public System.Collections.Generic.IEnumerable<T> GetConsumingEnumerable() { return default(System.Collections.Generic.IEnumerable<T>); }
+    [System.Diagnostics.DebuggerHiddenAttribute]
+    public System.Collections.Generic.IEnumerable<T> GetConsumingEnumerable(System.Threading.CancellationToken cancellationToken) { return default(System.Collections.Generic.IEnumerable<T>); }
+    System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public T Take() { return default(T); }
+    public T Take(System.Threading.CancellationToken cancellationToken) { return default(T); }
+    public static int TakeFromAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, out T item) { item = default(T); return default(int); }
+    public static int TakeFromAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, out T item, System.Threading.CancellationToken cancellationToken) { item = default(T); return default(int); }
+    public T[] ToArray() { return default(T[]); }
+    public bool TryAdd(T item) { return default(bool); }
+    public bool TryAdd(T item, int millisecondsTimeout) { return default(bool); }
+    public bool TryAdd(T item, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+    public bool TryAdd(T item, System.TimeSpan timeout) { return default(bool); }
+    public static int TryAddToAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, T item) { return default(int); }
+    public static int TryAddToAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, T item, int millisecondsTimeout) { return default(int); }
+    public static int TryAddToAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, T item, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { return default(int); }
+    public static int TryAddToAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, T item, System.TimeSpan timeout) { return default(int); }
+    public bool TryTake(out T item) { item = default(T); return default(bool); }
+    public bool TryTake(out T item, int millisecondsTimeout) { item = default(T); return default(bool); }
+    public bool TryTake(out T item, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { item = default(T); return default(bool); }
+    public bool TryTake(out T item, System.TimeSpan timeout) { item = default(T); return default(bool); }
+    public static int TryTakeFromAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, out T item) { item = default(T); return default(int); }
+    public static int TryTakeFromAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, out T item, int millisecondsTimeout) { item = default(T); return default(int); }
+    public static int TryTakeFromAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, out T item, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { item = default(T); return default(int); }
+    public static int TryTakeFromAny(System.Collections.Concurrent.BlockingCollection<T>[] collections, out T item, System.TimeSpan timeout) { item = default(T); return default(int); }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class ConcurrentBag<T> : System.Collections.Concurrent.IProducerConsumerCollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable {
+    public ConcurrentBag() { }
+    public ConcurrentBag(System.Collections.Generic.IEnumerable<T> collection) { }
+    public int Count { get { return default(int); } }
+    public bool IsEmpty { get { return default(bool); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public void Add(T item) { }
+    public void CopyTo(T[] array, int index) { }
+    public System.Collections.Generic.IEnumerator<T> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    bool System.Collections.Concurrent.IProducerConsumerCollection<T>.TryAdd(T item) { return default(bool); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public T[] ToArray() { return default(T[]); }
+    public bool TryPeek(out T result) { result = default(T); return default(bool); }
+    public bool TryTake(out T result) { result = default(T); return default(bool); }
+  }
+
+} // end of System.Collections.Concurrent

fxdac/fxdac/Data/Contracts/System.Collections.NonGeneric.cs

@@ -0,0 +1,193 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Collections {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class CaseInsensitiveComparer : System.Collections.IComparer {
+    public CaseInsensitiveComparer() { }
+    public CaseInsensitiveComparer(System.Globalization.CultureInfo culture) { }
+    public static System.Collections.CaseInsensitiveComparer Default { get { return default(System.Collections.CaseInsensitiveComparer); } }
+    public static System.Collections.CaseInsensitiveComparer DefaultInvariant { get { return default(System.Collections.CaseInsensitiveComparer); } }
+    public int Compare(object a, object b) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class CollectionBase : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList {
+    protected CollectionBase() { }
+    protected CollectionBase(int capacity) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public int Capacity { get { return default(int); } set { } }
+    public int Count { get { return default(int); } }
+    protected System.Collections.ArrayList InnerList { get { return default(System.Collections.ArrayList); } }
+    protected System.Collections.IList List { get { return default(System.Collections.IList); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    bool System.Collections.IList.IsFixedSize { get { return default(bool); } }
+    bool System.Collections.IList.IsReadOnly { get { return default(bool); } }
+    object System.Collections.IList.this[int index] { get { return default(object); } set { } }
+    public void Clear() { }
+    public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    protected virtual void OnClear() { }
+    protected virtual void OnClearComplete() { }
+    protected virtual void OnInsert(int index, object value) { }
+    protected virtual void OnInsertComplete(int index, object value) { }
+    protected virtual void OnRemove(int index, object value) { }
+    protected virtual void OnRemoveComplete(int index, object value) { }
+    protected virtual void OnSet(int index, object oldValue, object newValue) { }
+    protected virtual void OnSetComplete(int index, object oldValue, object newValue) { }
+    protected virtual void OnValidate(object value) { }
+    public void RemoveAt(int index) { }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    int System.Collections.IList.Add(object value) { return default(int); }
+    bool System.Collections.IList.Contains(object value) { return default(bool); }
+    int System.Collections.IList.IndexOf(object value) { return default(int); }
+    void System.Collections.IList.Insert(int index, object value) { }
+    void System.Collections.IList.Remove(object value) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Comparer : System.Collections.IComparer, System.Runtime.Serialization.ISerializable {
+    public static readonly System.Collections.Comparer Default;
+    public static readonly System.Collections.Comparer DefaultInvariant;
+    public Comparer(System.Globalization.CultureInfo culture) { }
+    public int Compare(object a, object b) { return default(int); }
+    [System.Security.SecurityCriticalAttribute]
+    public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class DictionaryBase : System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable {
+    protected DictionaryBase() { }
+    public int Count { get { return default(int); } }
+    protected System.Collections.IDictionary Dictionary { get { return default(System.Collections.IDictionary); } }
+    protected System.Collections.Hashtable InnerHashtable { get { return default(System.Collections.Hashtable); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    bool System.Collections.IDictionary.IsFixedSize { get { return default(bool); } }
+    bool System.Collections.IDictionary.IsReadOnly { get { return default(bool); } }
+    object System.Collections.IDictionary.this[object key] { get { return default(object); } set { } }
+    System.Collections.ICollection System.Collections.IDictionary.Keys { get { return default(System.Collections.ICollection); } }
+    System.Collections.ICollection System.Collections.IDictionary.Values { get { return default(System.Collections.ICollection); } }
+    public void Clear() { }
+    public void CopyTo(System.Array array, int index) { }
+    public System.Collections.IDictionaryEnumerator GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    protected virtual void OnClear() { }
+    protected virtual void OnClearComplete() { }
+    protected virtual object OnGet(object key, object currentValue) { return default(object); }
+    protected virtual void OnInsert(object key, object value) { }
+    protected virtual void OnInsertComplete(object key, object value) { }
+    protected virtual void OnRemove(object key, object value) { }
+    protected virtual void OnRemoveComplete(object key, object value) { }
+    protected virtual void OnSet(object key, object oldValue, object newValue) { }
+    protected virtual void OnSetComplete(object key, object oldValue, object newValue) { }
+    protected virtual void OnValidate(object key, object value) { }
+    void System.Collections.IDictionary.Add(object key, object value) { }
+    bool System.Collections.IDictionary.Contains(object key) { return default(bool); }
+    void System.Collections.IDictionary.Remove(object key) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class Queue : System.Collections.ICollection, System.Collections.IEnumerable, System.ICloneable {
+    public Queue() { }
+    public Queue(System.Collections.ICollection col) { }
+    public Queue(int capacity) { }
+    public Queue(int capacity, float growFactor) { }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsSynchronized { get { return default(bool); } }
+    public virtual object SyncRoot { get { return default(object); } }
+    public virtual void Clear() { }
+    public virtual object Clone() { return default(object); }
+    public virtual bool Contains(object obj) { return default(bool); }
+    public virtual void CopyTo(System.Array array, int index) { }
+    public virtual object Dequeue() { return default(object); }
+    public virtual void Enqueue(object obj) { }
+    public virtual System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public virtual object Peek() { return default(object); }
+    public static System.Collections.Queue Synchronized(System.Collections.Queue queue) { return default(System.Collections.Queue); }
+    public virtual object[] ToArray() { return default(object[]); }
+    public virtual void TrimToSize() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class ReadOnlyCollectionBase : System.Collections.ICollection, System.Collections.IEnumerable {
+    protected ReadOnlyCollectionBase() { }
+    public virtual int Count { get { return default(int); } }
+    protected System.Collections.ArrayList InnerList { get { return default(System.Collections.ArrayList); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public virtual System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class SortedList : System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable, System.ICloneable {
+    public SortedList() { }
+    public SortedList(System.Collections.IComparer comparer) { }
+    public SortedList(System.Collections.IComparer comparer, int capacity) { }
+    public SortedList(System.Collections.IDictionary d) { }
+    public SortedList(System.Collections.IDictionary d, System.Collections.IComparer comparer) { }
+    public SortedList(int initialCapacity) { }
+    public virtual int Capacity { get { return default(int); } set { } }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsFixedSize { get { return default(bool); } }
+    public virtual bool IsReadOnly { get { return default(bool); } }
+    public virtual bool IsSynchronized { get { return default(bool); } }
+    public virtual object this[object key] { get { return default(object); } set { } }
+    public virtual System.Collections.ICollection Keys { get { return default(System.Collections.ICollection); } }
+    public virtual object SyncRoot { get { return default(object); } }
+    public virtual System.Collections.ICollection Values { get { return default(System.Collections.ICollection); } }
+    public virtual void Add(object key, object value) { }
+    public virtual void Clear() { }
+    public virtual object Clone() { return default(object); }
+    public virtual bool Contains(object key) { return default(bool); }
+    public virtual bool ContainsKey(object key) { return default(bool); }
+    public virtual bool ContainsValue(object value) { return default(bool); }
+    public virtual void CopyTo(System.Array array, int arrayIndex) { }
+    public virtual object GetByIndex(int index) { return default(object); }
+    public virtual System.Collections.IDictionaryEnumerator GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    public virtual object GetKey(int index) { return default(object); }
+    public virtual System.Collections.IList GetKeyList() { return default(System.Collections.IList); }
+    public virtual System.Collections.IList GetValueList() { return default(System.Collections.IList); }
+    public virtual int IndexOfKey(object key) { return default(int); }
+    public virtual int IndexOfValue(object value) { return default(int); }
+    public virtual void Remove(object key) { }
+    public virtual void RemoveAt(int index) { }
+    public virtual void SetByIndex(int index, object value) { }
+    public static System.Collections.SortedList Synchronized(System.Collections.SortedList list) { return default(System.Collections.SortedList); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public virtual void TrimToSize() { }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class Stack : System.Collections.ICollection, System.Collections.IEnumerable, System.ICloneable {
+    public Stack() { }
+    public Stack(System.Collections.ICollection col) { }
+    public Stack(int initialCapacity) { }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsSynchronized { get { return default(bool); } }
+    public virtual object SyncRoot { get { return default(object); } }
+    public virtual void Clear() { }
+    public virtual object Clone() { return default(object); }
+    public virtual bool Contains(object obj) { return default(bool); }
+    public virtual void CopyTo(System.Array array, int index) { }
+    public virtual System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public virtual object Peek() { return default(object); }
+    public virtual object Pop() { return default(object); }
+    public virtual void Push(object obj) { }
+    public static System.Collections.Stack Synchronized(System.Collections.Stack stack) { return default(System.Collections.Stack); }
+    public virtual object[] ToArray() { return default(object[]); }
+  }
+
+} // end of System.Collections
+namespace System.Collections.Specialized {
+  public partial class CollectionsUtil {
+    public CollectionsUtil() { }
+    public static System.Collections.Hashtable CreateCaseInsensitiveHashtable() { return default(System.Collections.Hashtable); }
+    public static System.Collections.Hashtable CreateCaseInsensitiveHashtable(System.Collections.IDictionary d) { return default(System.Collections.Hashtable); }
+    public static System.Collections.Hashtable CreateCaseInsensitiveHashtable(int capacity) { return default(System.Collections.Hashtable); }
+    public static System.Collections.SortedList CreateCaseInsensitiveSortedList() { return default(System.Collections.SortedList); }
+  }
+
+} // end of System.Collections.Specialized

fxdac/fxdac/Data/Contracts/System.Collections.Specialized.cs

@@ -0,0 +1,238 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Collections.Specialized {
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct BitVector32 {
+    public BitVector32(System.Collections.Specialized.BitVector32 value) { throw new System.NotImplementedException(); }
+    public BitVector32(int data) { throw new System.NotImplementedException(); }
+    public int Data { get { return default(int); } }
+    public int this[System.Collections.Specialized.BitVector32.Section section] { get { return default(int); } set { } }
+    public bool this[int bit] { get { return default(bool); } set { } }
+    public static int CreateMask() { return default(int); }
+    public static int CreateMask(int previous) { return default(int); }
+    public static System.Collections.Specialized.BitVector32.Section CreateSection(short maxValue) { return default(System.Collections.Specialized.BitVector32.Section); }
+    public static System.Collections.Specialized.BitVector32.Section CreateSection(short maxValue, System.Collections.Specialized.BitVector32.Section previous) { return default(System.Collections.Specialized.BitVector32.Section); }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+    public static string ToString(System.Collections.Specialized.BitVector32 value) { return default(string); }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct Section {
+      public short Mask { get { return default(short); } }
+      public short Offset { get { return default(short); } }
+      public bool Equals(System.Collections.Specialized.BitVector32.Section obj) { return default(bool); }
+      public override bool Equals(object o) { return default(bool); }
+      public override int GetHashCode() { return default(int); }
+      public static bool operator ==(System.Collections.Specialized.BitVector32.Section a, System.Collections.Specialized.BitVector32.Section b) { return default(bool); }
+      public static bool operator !=(System.Collections.Specialized.BitVector32.Section a, System.Collections.Specialized.BitVector32.Section b) { return default(bool); }
+      public override string ToString() { return default(string); }
+      public static string ToString(System.Collections.Specialized.BitVector32.Section value) { return default(string); }
+    }
+  }
+
+  public partial class HybridDictionary : System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable {
+    public HybridDictionary() { }
+    public HybridDictionary(bool caseInsensitive) { }
+    public HybridDictionary(int initialSize) { }
+    public HybridDictionary(int initialSize, bool caseInsensitive) { }
+    public int Count { get { return default(int); } }
+    public bool IsFixedSize { get { return default(bool); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public object this[object key] { get { return default(object); } set { } }
+    public System.Collections.ICollection Keys { get { return default(System.Collections.ICollection); } }
+    public object SyncRoot { get { return default(object); } }
+    public System.Collections.ICollection Values { get { return default(System.Collections.ICollection); } }
+    public void Add(object key, object value) { }
+    public void Clear() { }
+    public bool Contains(object key) { return default(bool); }
+    public void CopyTo(System.Array array, int index) { }
+    public System.Collections.IDictionaryEnumerator GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    public void Remove(object key) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public partial interface IOrderedDictionary : System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable {
+    object this[int index] { get; set; }
+    new System.Collections.IDictionaryEnumerator GetEnumerator();
+    void Insert(int index, object key, object value);
+    void RemoveAt(int index);
+  }
+
+  public partial class ListDictionary : System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable {
+    public ListDictionary() { }
+    public ListDictionary(System.Collections.IComparer comparer) { }
+    public int Count { get { return default(int); } }
+    public bool IsFixedSize { get { return default(bool); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public object this[object key] { get { return default(object); } set { } }
+    public System.Collections.ICollection Keys { get { return default(System.Collections.ICollection); } }
+    public object SyncRoot { get { return default(object); } }
+    public System.Collections.ICollection Values { get { return default(System.Collections.ICollection); } }
+    public void Add(object key, object value) { }
+    public void Clear() { }
+    public bool Contains(object key) { return default(bool); }
+    public void CopyTo(System.Array array, int index) { }
+    public System.Collections.IDictionaryEnumerator GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    public void Remove(object key) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public abstract partial class NameObjectCollectionBase : System.Collections.ICollection, System.Collections.IEnumerable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable {
+    protected NameObjectCollectionBase() { }
+    protected NameObjectCollectionBase(System.Collections.IEqualityComparer equalityComparer) { }
+    [System.ObsoleteAttribute("Please use NameObjectCollectionBase(IEqualityComparer) instead.")]
+    protected NameObjectCollectionBase(System.Collections.IHashCodeProvider hashProvider, System.Collections.IComparer comparer) { }
+    protected NameObjectCollectionBase(int capacity) { }
+    protected NameObjectCollectionBase(int capacity, System.Collections.IEqualityComparer equalityComparer) { }
+    [System.ObsoleteAttribute("Please use NameObjectCollectionBase(Int32, IEqualityComparer) instead.")]
+    protected NameObjectCollectionBase(int capacity, System.Collections.IHashCodeProvider hashProvider, System.Collections.IComparer comparer) { }
+    protected NameObjectCollectionBase(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public virtual int Count { get { return default(int); } }
+    protected bool IsReadOnly { get { return default(bool); } set { } }
+    public virtual System.Collections.Specialized.NameObjectCollectionBase.KeysCollection Keys { get { return default(System.Collections.Specialized.NameObjectCollectionBase.KeysCollection); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    protected void BaseAdd(string name, object value) { }
+    protected void BaseClear() { }
+    protected object BaseGet(int index) { return default(object); }
+    protected object BaseGet(string name) { return default(object); }
+    protected string[] BaseGetAllKeys() { return default(string[]); }
+    protected object[] BaseGetAllValues() { return default(object[]); }
+    protected object[] BaseGetAllValues(System.Type type) { return default(object[]); }
+    protected string BaseGetKey(int index) { return default(string); }
+    protected bool BaseHasKeys() { return default(bool); }
+    protected void BaseRemove(string name) { }
+    protected void BaseRemoveAt(int index) { }
+    protected void BaseSet(int index, object value) { }
+    protected void BaseSet(string name, object value) { }
+    public virtual System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public virtual void OnDeserialization(object sender) { }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    public partial class KeysCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+      internal KeysCollection() { }
+      public int Count { get { return default(int); } }
+      public string this[int index] { get { return default(string); } }
+      bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+      object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+      public virtual string Get(int index) { return default(string); }
+      public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+      void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    }
+  }
+
+  public partial class NameValueCollection : System.Collections.Specialized.NameObjectCollectionBase {
+    public NameValueCollection() { }
+    public NameValueCollection(System.Collections.IEqualityComparer equalityComparer) { }
+    [System.ObsoleteAttribute("Please use NameValueCollection(IEqualityComparer) instead.")]
+    public NameValueCollection(System.Collections.IHashCodeProvider hashProvider, System.Collections.IComparer comparer) { }
+    public NameValueCollection(System.Collections.Specialized.NameValueCollection col) { }
+    public NameValueCollection(int capacity) { }
+    public NameValueCollection(int capacity, System.Collections.IEqualityComparer equalityComparer) { }
+    [System.ObsoleteAttribute("Please use NameValueCollection(Int32, IEqualityComparer) instead.")]
+    public NameValueCollection(int capacity, System.Collections.IHashCodeProvider hashProvider, System.Collections.IComparer comparer) { }
+    public NameValueCollection(int capacity, System.Collections.Specialized.NameValueCollection col) { }
+    protected NameValueCollection(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public virtual string[] AllKeys { get { return default(string[]); } }
+    public string this[int index] { get { return default(string); } }
+    public string this[string name] { get { return default(string); } set { } }
+    public void Add(System.Collections.Specialized.NameValueCollection c) { }
+    public virtual void Add(string name, string value) { }
+    public virtual void Clear() { }
+    public void CopyTo(System.Array dest, int index) { }
+    public virtual string Get(int index) { return default(string); }
+    public virtual string Get(string name) { return default(string); }
+    public virtual string GetKey(int index) { return default(string); }
+    public virtual string[] GetValues(int index) { return default(string[]); }
+    public virtual string[] GetValues(string name) { return default(string[]); }
+    public bool HasKeys() { return default(bool); }
+    protected void InvalidateCachedArrays() { }
+    public virtual void Remove(string name) { }
+    public virtual void Set(string name, string value) { }
+  }
+
+  public partial class OrderedDictionary : System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable, System.Collections.Specialized.IOrderedDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable {
+    public OrderedDictionary() { }
+    public OrderedDictionary(System.Collections.IEqualityComparer comparer) { }
+    public OrderedDictionary(int capacity) { }
+    public OrderedDictionary(int capacity, System.Collections.IEqualityComparer comparer) { }
+    protected OrderedDictionary(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public object this[int index] { get { return default(object); } set { } }
+    public object this[object key] { get { return default(object); } set { } }
+    public System.Collections.ICollection Keys { get { return default(System.Collections.ICollection); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    bool System.Collections.IDictionary.IsFixedSize { get { return default(bool); } }
+    public System.Collections.ICollection Values { get { return default(System.Collections.ICollection); } }
+    public void Add(object key, object value) { }
+    public System.Collections.Specialized.OrderedDictionary AsReadOnly() { return default(System.Collections.Specialized.OrderedDictionary); }
+    public void Clear() { }
+    public bool Contains(object key) { return default(bool); }
+    public void CopyTo(System.Array array, int index) { }
+    public virtual System.Collections.IDictionaryEnumerator GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public void Insert(int index, object key, object value) { }
+    protected virtual void OnDeserialization(object sender) { }
+    public void Remove(object key) { }
+    public void RemoveAt(int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender) { }
+  }
+
+  public partial class StringCollection : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList {
+    public StringCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public string this[int index] { get { return default(string); } set { } }
+    public object SyncRoot { get { return default(object); } }
+    bool System.Collections.IList.IsFixedSize { get { return default(bool); } }
+    bool System.Collections.IList.IsReadOnly { get { return default(bool); } }
+    object System.Collections.IList.this[int index] { get { return default(object); } set { } }
+    public int Add(string value) { return default(int); }
+    public void AddRange(string[] value) { }
+    public void Clear() { }
+    public bool Contains(string value) { return default(bool); }
+    public void CopyTo(string[] array, int index) { }
+    public System.Collections.Specialized.StringEnumerator GetEnumerator() { return default(System.Collections.Specialized.StringEnumerator); }
+    public int IndexOf(string value) { return default(int); }
+    public void Insert(int index, string value) { }
+    public void Remove(string value) { }
+    public void RemoveAt(int index) { }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    int System.Collections.IList.Add(object value) { return default(int); }
+    bool System.Collections.IList.Contains(object value) { return default(bool); }
+    int System.Collections.IList.IndexOf(object value) { return default(int); }
+    void System.Collections.IList.Insert(int index, object value) { }
+    void System.Collections.IList.Remove(object value) { }
+  }
+
+  public partial class StringDictionary : System.Collections.IEnumerable {
+    public StringDictionary() { }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsSynchronized { get { return default(bool); } }
+    public virtual string this[string key] { get { return default(string); } set { } }
+    public virtual System.Collections.ICollection Keys { get { return default(System.Collections.ICollection); } }
+    public virtual object SyncRoot { get { return default(object); } }
+    public virtual System.Collections.ICollection Values { get { return default(System.Collections.ICollection); } }
+    public virtual void Add(string key, string value) { }
+    public virtual void Clear() { }
+    public virtual bool ContainsKey(string key) { return default(bool); }
+    public virtual bool ContainsValue(string value) { return default(bool); }
+    public virtual void CopyTo(System.Array array, int index) { }
+    public virtual System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public virtual void Remove(string key) { }
+  }
+
+  public partial class StringEnumerator {
+    internal StringEnumerator() { }
+    public string Current { get { return default(string); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+} // end of System.Collections.Specialized

fxdac/fxdac/Data/Contracts/System.Collections.cs

@@ -0,0 +1,425 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Collections {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class BitArray : System.Collections.ICollection, System.Collections.IEnumerable, System.ICloneable {
+    public BitArray(bool[] values) { }
+    public BitArray(byte[] bytes) { }
+    public BitArray(System.Collections.BitArray bits) { }
+    public BitArray(int length) { }
+    public BitArray(int length, bool defaultValue) { }
+    public BitArray(int[] values) { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public bool this[int index] { get { return default(bool); } set { } }
+    public int Length { get { return default(int); } set { } }
+    public object SyncRoot { get { return default(object); } }
+    public System.Collections.BitArray And(System.Collections.BitArray value) { return default(System.Collections.BitArray); }
+    public object Clone() { return default(object); }
+    public void CopyTo(System.Array array, int index) { }
+    public bool Get(int index) { return default(bool); }
+    public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public System.Collections.BitArray Not() { return default(System.Collections.BitArray); }
+    public System.Collections.BitArray Or(System.Collections.BitArray value) { return default(System.Collections.BitArray); }
+    public void Set(int index, bool value) { }
+    public void SetAll(bool value) { }
+    public System.Collections.BitArray Xor(System.Collections.BitArray value) { return default(System.Collections.BitArray); }
+  }
+
+  [System.ObsoleteAttribute("Please use StringComparer instead.")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class CaseInsensitiveHashCodeProvider : System.Collections.IHashCodeProvider {
+    public CaseInsensitiveHashCodeProvider() { }
+    public CaseInsensitiveHashCodeProvider(System.Globalization.CultureInfo culture) { }
+    public static System.Collections.CaseInsensitiveHashCodeProvider Default { get { return default(System.Collections.CaseInsensitiveHashCodeProvider); } }
+    public static System.Collections.CaseInsensitiveHashCodeProvider DefaultInvariant { get { return default(System.Collections.CaseInsensitiveHashCodeProvider); } }
+    public int GetHashCode(object obj) { return default(int); }
+  }
+
+  public static partial class StructuralComparisons {
+    public static System.Collections.IComparer StructuralComparer { get { return default(System.Collections.IComparer); } }
+    public static System.Collections.IEqualityComparer StructuralEqualityComparer { get { return default(System.Collections.IEqualityComparer); } }
+  }
+
+} // end of System.Collections
+namespace System.Collections.Generic {
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class LinkedList<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable {
+    public LinkedList() { }
+    public LinkedList(System.Collections.Generic.IEnumerable<T> collection) { }
+    protected LinkedList(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public int Count { get { return default(int); } }
+    public System.Collections.Generic.LinkedListNode<T> First { get { return default(System.Collections.Generic.LinkedListNode<T>); } }
+    public System.Collections.Generic.LinkedListNode<T> Last { get { return default(System.Collections.Generic.LinkedListNode<T>); } }
+    bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { return default(bool); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public System.Collections.Generic.LinkedListNode<T> AddAfter(System.Collections.Generic.LinkedListNode<T> node, T value) { return default(System.Collections.Generic.LinkedListNode<T>); }
+    public void AddAfter(System.Collections.Generic.LinkedListNode<T> node, System.Collections.Generic.LinkedListNode<T> newNode) { }
+    public System.Collections.Generic.LinkedListNode<T> AddBefore(System.Collections.Generic.LinkedListNode<T> node, T value) { return default(System.Collections.Generic.LinkedListNode<T>); }
+    public void AddBefore(System.Collections.Generic.LinkedListNode<T> node, System.Collections.Generic.LinkedListNode<T> newNode) { }
+    public System.Collections.Generic.LinkedListNode<T> AddFirst(T value) { return default(System.Collections.Generic.LinkedListNode<T>); }
+    public void AddFirst(System.Collections.Generic.LinkedListNode<T> node) { }
+    public System.Collections.Generic.LinkedListNode<T> AddLast(T value) { return default(System.Collections.Generic.LinkedListNode<T>); }
+    public void AddLast(System.Collections.Generic.LinkedListNode<T> node) { }
+    public void Clear() { }
+    public bool Contains(T value) { return default(bool); }
+    public void CopyTo(T[] array, int index) { }
+    public System.Collections.Generic.LinkedListNode<T> Find(T value) { return default(System.Collections.Generic.LinkedListNode<T>); }
+    public System.Collections.Generic.LinkedListNode<T> FindLast(T value) { return default(System.Collections.Generic.LinkedListNode<T>); }
+    public System.Collections.Generic.LinkedList<T>.Enumerator GetEnumerator() { return default(System.Collections.Generic.LinkedList<T>.Enumerator); }
+    public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public virtual void OnDeserialization(object sender) { }
+    public bool Remove(T value) { return default(bool); }
+    public void Remove(System.Collections.Generic.LinkedListNode<T> node) { }
+    public void RemoveFirst() { }
+    public void RemoveLast() { }
+    void System.Collections.Generic.ICollection<T>.Add(T value) { }
+    System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable {
+      public T Current { get { return default(T); } }
+      object System.Collections.IEnumerator.Current { get { return default(object); } }
+      public void Dispose() { }
+      public bool MoveNext() { return default(bool); }
+      void System.Collections.IEnumerator.Reset() { }
+      void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender) { }
+      void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public sealed partial class LinkedListNode<T> {
+    public LinkedListNode(T value) { }
+    public System.Collections.Generic.LinkedList<T> List { get { return default(System.Collections.Generic.LinkedList<T>); } }
+    public System.Collections.Generic.LinkedListNode<T> Next { get { return default(System.Collections.Generic.LinkedListNode<T>); } }
+    public System.Collections.Generic.LinkedListNode<T> Previous { get { return default(System.Collections.Generic.LinkedListNode<T>); } }
+    public T Value { get { return default(T); } set { } }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable {
+    public Queue() { }
+    public Queue(System.Collections.Generic.IEnumerable<T> collection) { }
+    public Queue(int capacity) { }
+    public int Count { get { return default(int); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public void Clear() { }
+    public bool Contains(T item) { return default(bool); }
+    public void CopyTo(T[] array, int arrayIndex) { }
+    public T Dequeue() { return default(T); }
+    public void Enqueue(T item) { }
+    public System.Collections.Generic.Queue<T>.Enumerator GetEnumerator() { return default(System.Collections.Generic.Queue<T>.Enumerator); }
+    public T Peek() { return default(T); }
+    System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public T[] ToArray() { return default(T[]); }
+    public void TrimExcess() { }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable {
+      public T Current { get { return default(T); } }
+      object System.Collections.IEnumerator.Current { get { return default(object); } }
+      public void Dispose() { }
+      public bool MoveNext() { return default(bool); }
+      void System.Collections.IEnumerator.Reset() { }
+    }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  public partial class SortedDictionary<TKey, TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IDictionary<TKey, TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable {
+    public SortedDictionary() { }
+    public SortedDictionary(System.Collections.Generic.IComparer<TKey> comparer) { }
+    public SortedDictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary) { }
+    public SortedDictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary, System.Collections.Generic.IComparer<TKey> comparer) { }
+    public System.Collections.Generic.IComparer<TKey> Comparer { get { return default(System.Collections.Generic.IComparer<TKey>); } }
+    public int Count { get { return default(int); } }
+    public TValue this[TKey key] { get { return default(TValue); } set { } }
+    public System.Collections.Generic.SortedDictionary<TKey, TValue>.KeyCollection Keys { get { return default(System.Collections.Generic.SortedDictionary<TKey, TValue>.KeyCollection); } }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get { return default(bool); } }
+    System.Collections.Generic.ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get { return default(System.Collections.Generic.ICollection<TKey>); } }
+    System.Collections.Generic.ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get { return default(System.Collections.Generic.ICollection<TValue>); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    bool System.Collections.IDictionary.IsFixedSize { get { return default(bool); } }
+    bool System.Collections.IDictionary.IsReadOnly { get { return default(bool); } }
+    object System.Collections.IDictionary.this[object key] { get { return default(object); } set { } }
+    System.Collections.ICollection System.Collections.IDictionary.Keys { get { return default(System.Collections.ICollection); } }
+    System.Collections.ICollection System.Collections.IDictionary.Values { get { return default(System.Collections.ICollection); } }
+    public System.Collections.Generic.SortedDictionary<TKey, TValue>.ValueCollection Values { get { return default(System.Collections.Generic.SortedDictionary<TKey, TValue>.ValueCollection); } }
+    public void Add(TKey key, TValue value) { }
+    public void Clear() { }
+    public bool ContainsKey(TKey key) { return default(bool); }
+    public bool ContainsValue(TValue value) { return default(bool); }
+    public void CopyTo(System.Collections.Generic.KeyValuePair<TKey, TValue>[] array, int index) { }
+    public System.Collections.Generic.SortedDictionary<TKey, TValue>.Enumerator GetEnumerator() { return default(System.Collections.Generic.SortedDictionary<TKey, TValue>.Enumerator); }
+    public bool Remove(TKey key) { return default(bool); }
+    void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Contains(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { return default(bool); }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { return default(bool); }
+    System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    void System.Collections.IDictionary.Add(object key, object value) { }
+    bool System.Collections.IDictionary.Contains(object key) { return default(bool); }
+    System.Collections.IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    void System.Collections.IDictionary.Remove(object key) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public bool TryGetValue(TKey key, out TValue value) { value = default(TValue); return default(bool); }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct Enumerator : System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.IDictionaryEnumerator, System.Collections.IEnumerator, System.IDisposable {
+      public System.Collections.Generic.KeyValuePair<TKey, TValue> Current { get { return default(System.Collections.Generic.KeyValuePair<TKey, TValue>); } }
+      System.Collections.DictionaryEntry System.Collections.IDictionaryEnumerator.Entry { get { return default(System.Collections.DictionaryEntry); } }
+      object System.Collections.IDictionaryEnumerator.Key { get { return default(object); } }
+      object System.Collections.IDictionaryEnumerator.Value { get { return default(object); } }
+      object System.Collections.IEnumerator.Current { get { return default(object); } }
+      public void Dispose() { }
+      public bool MoveNext() { return default(bool); }
+      void System.Collections.IEnumerator.Reset() { }
+    }
+    [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+    public sealed partial class KeyCollection : System.Collections.Generic.ICollection<TKey>, System.Collections.Generic.IEnumerable<TKey>, System.Collections.ICollection, System.Collections.IEnumerable {
+      public KeyCollection(System.Collections.Generic.SortedDictionary<TKey, TValue> dictionary) { }
+      public int Count { get { return default(int); } }
+      bool System.Collections.Generic.ICollection<TKey>.IsReadOnly { get { return default(bool); } }
+      bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+      object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+      public void CopyTo(TKey[] array, int index) { }
+      public System.Collections.Generic.SortedDictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator() { return default(System.Collections.Generic.SortedDictionary<TKey, TValue>.KeyCollection.Enumerator); }
+      void System.Collections.Generic.ICollection<TKey>.Add(TKey item) { }
+      void System.Collections.Generic.ICollection<TKey>.Clear() { }
+      bool System.Collections.Generic.ICollection<TKey>.Contains(TKey item) { return default(bool); }
+      bool System.Collections.Generic.ICollection<TKey>.Remove(TKey item) { return default(bool); }
+      System.Collections.Generic.IEnumerator<TKey> System.Collections.Generic.IEnumerable<TKey>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<TKey>); }
+      void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+      System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+      [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+      public partial struct Enumerator : System.Collections.Generic.IEnumerator<TKey>, System.Collections.IEnumerator, System.IDisposable {
+        public TKey Current { get { return default(TKey); } }
+        object System.Collections.IEnumerator.Current { get { return default(object); } }
+        public void Dispose() { }
+        public bool MoveNext() { return default(bool); }
+        void System.Collections.IEnumerator.Reset() { }
+      }
+    }
+    [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+    public sealed partial class ValueCollection : System.Collections.Generic.ICollection<TValue>, System.Collections.Generic.IEnumerable<TValue>, System.Collections.ICollection, System.Collections.IEnumerable {
+      public ValueCollection(System.Collections.Generic.SortedDictionary<TKey, TValue> dictionary) { }
+      public int Count { get { return default(int); } }
+      bool System.Collections.Generic.ICollection<TValue>.IsReadOnly { get { return default(bool); } }
+      bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+      object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+      public void CopyTo(TValue[] array, int index) { }
+      public System.Collections.Generic.SortedDictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator() { return default(System.Collections.Generic.SortedDictionary<TKey, TValue>.ValueCollection.Enumerator); }
+      void System.Collections.Generic.ICollection<TValue>.Add(TValue item) { }
+      void System.Collections.Generic.ICollection<TValue>.Clear() { }
+      bool System.Collections.Generic.ICollection<TValue>.Contains(TValue item) { return default(bool); }
+      bool System.Collections.Generic.ICollection<TValue>.Remove(TValue item) { return default(bool); }
+      System.Collections.Generic.IEnumerator<TValue> System.Collections.Generic.IEnumerable<TValue>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<TValue>); }
+      void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+      System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+      [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+      public partial struct Enumerator : System.Collections.Generic.IEnumerator<TValue>, System.Collections.IEnumerator, System.IDisposable {
+        public TValue Current { get { return default(TValue); } }
+        object System.Collections.IEnumerator.Current { get { return default(object); } }
+        public void Dispose() { }
+        public bool MoveNext() { return default(bool); }
+        void System.Collections.IEnumerator.Reset() { }
+      }
+    }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class SortedList<TKey, TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IDictionary<TKey, TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable {
+    public SortedList() { }
+    public SortedList(System.Collections.Generic.IComparer<TKey> comparer) { }
+    public SortedList(System.Collections.Generic.IDictionary<TKey, TValue> dictionary) { }
+    public SortedList(System.Collections.Generic.IDictionary<TKey, TValue> dictionary, System.Collections.Generic.IComparer<TKey> comparer) { }
+    public SortedList(int capacity) { }
+    public SortedList(int capacity, System.Collections.Generic.IComparer<TKey> comparer) { }
+    public int Capacity { get { return default(int); } set { } }
+    public System.Collections.Generic.IComparer<TKey> Comparer { get { return default(System.Collections.Generic.IComparer<TKey>); } }
+    public int Count { get { return default(int); } }
+    public TValue this[TKey key] { get { return default(TValue); } set { } }
+    public System.Collections.Generic.IList<TKey> Keys { get { return default(System.Collections.Generic.IList<TKey>); } }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get { return default(bool); } }
+    System.Collections.Generic.ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get { return default(System.Collections.Generic.ICollection<TKey>); } }
+    System.Collections.Generic.ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get { return default(System.Collections.Generic.ICollection<TValue>); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    bool System.Collections.IDictionary.IsFixedSize { get { return default(bool); } }
+    bool System.Collections.IDictionary.IsReadOnly { get { return default(bool); } }
+    object System.Collections.IDictionary.this[object key] { get { return default(object); } set { } }
+    System.Collections.ICollection System.Collections.IDictionary.Keys { get { return default(System.Collections.ICollection); } }
+    System.Collections.ICollection System.Collections.IDictionary.Values { get { return default(System.Collections.ICollection); } }
+    public System.Collections.Generic.IList<TValue> Values { get { return default(System.Collections.Generic.IList<TValue>); } }
+    public void Add(TKey key, TValue value) { }
+    public void Clear() { }
+    public bool ContainsKey(TKey key) { return default(bool); }
+    public bool ContainsValue(TValue value) { return default(bool); }
+    public System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>); }
+    public int IndexOfKey(TKey key) { return default(int); }
+    public int IndexOfValue(TValue value) { return default(int); }
+    public bool Remove(TKey key) { return default(bool); }
+    public void RemoveAt(int index) { }
+    void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Contains(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { return default(bool); }
+    void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(System.Collections.Generic.KeyValuePair<TKey, TValue>[] array, int arrayIndex) { }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { return default(bool); }
+    System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int arrayIndex) { }
+    void System.Collections.IDictionary.Add(object key, object value) { }
+    bool System.Collections.IDictionary.Contains(object key) { return default(bool); }
+    System.Collections.IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    void System.Collections.IDictionary.Remove(object key) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public void TrimExcess() { }
+    public bool TryGetValue(TKey key, out TValue value) { value = default(TValue); return default(bool); }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  public partial class SortedSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.ISet<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable {
+    public SortedSet() { }
+    public SortedSet(System.Collections.Generic.IComparer<T> comparer) { }
+    public SortedSet(System.Collections.Generic.IEnumerable<T> collection) { }
+    public SortedSet(System.Collections.Generic.IEnumerable<T> collection, System.Collections.Generic.IComparer<T> comparer) { }
+    protected SortedSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public System.Collections.Generic.IComparer<T> Comparer { get { return default(System.Collections.Generic.IComparer<T>); } }
+    public int Count { get { return default(int); } }
+    public T Max { get { return default(T); } }
+    public T Min { get { return default(T); } }
+    bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { return default(bool); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public bool Add(T item) { return default(bool); }
+    public virtual void Clear() { }
+    public virtual bool Contains(T item) { return default(bool); }
+    public void CopyTo(T[] array) { }
+    public void CopyTo(T[] array, int index) { }
+    public void CopyTo(T[] array, int index, int count) { }
+    public static System.Collections.Generic.IEqualityComparer<System.Collections.Generic.SortedSet<T>> CreateSetComparer() { return default(System.Collections.Generic.IEqualityComparer<System.Collections.Generic.SortedSet<T>>); }
+    public static System.Collections.Generic.IEqualityComparer<System.Collections.Generic.SortedSet<T>> CreateSetComparer(System.Collections.Generic.IEqualityComparer<T> memberEqualityComparer) { return default(System.Collections.Generic.IEqualityComparer<System.Collections.Generic.SortedSet<T>>); }
+    public void ExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
+    public System.Collections.Generic.SortedSet<T>.Enumerator GetEnumerator() { return default(System.Collections.Generic.SortedSet<T>.Enumerator); }
+    protected virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public virtual System.Collections.Generic.SortedSet<T> GetViewBetween(T lowerValue, T upperValue) { return default(System.Collections.Generic.SortedSet<T>); }
+    public virtual void IntersectWith(System.Collections.Generic.IEnumerable<T> other) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public bool IsProperSubsetOf(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public bool IsProperSupersetOf(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public bool IsSubsetOf(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public bool IsSupersetOf(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    protected virtual void OnDeserialization(object sender) { }
+    public bool Overlaps(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public bool Remove(T item) { return default(bool); }
+    public int RemoveWhere(System.Predicate<T> match) { return default(int); }
+    [System.Diagnostics.DebuggerHiddenAttribute]
+    public System.Collections.Generic.IEnumerable<T> Reverse() { return default(System.Collections.Generic.IEnumerable<T>); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public bool SetEquals(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public void SymmetricExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
+    void System.Collections.Generic.ICollection<T>.Add(T item) { }
+    System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public void UnionWith(System.Collections.Generic.IEnumerable<T> other) { }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable {
+      public T Current { get { return default(T); } }
+      object System.Collections.IEnumerator.Current { get { return default(object); } }
+      public void Dispose() { }
+      public bool MoveNext() { return default(bool); }
+      void System.Collections.IEnumerator.Reset() { }
+      void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender) { }
+      void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class Stack<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable {
+    public Stack() { }
+    public Stack(System.Collections.Generic.IEnumerable<T> collection) { }
+    public Stack(int capacity) { }
+    public int Count { get { return default(int); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    public void Clear() { }
+    public bool Contains(T item) { return default(bool); }
+    public void CopyTo(T[] array, int arrayIndex) { }
+    public System.Collections.Generic.Stack<T>.Enumerator GetEnumerator() { return default(System.Collections.Generic.Stack<T>.Enumerator); }
+    public T Peek() { return default(T); }
+    public T Pop() { return default(T); }
+    public void Push(T item) { }
+    System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int arrayIndex) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public T[] ToArray() { return default(T[]); }
+    public void TrimExcess() { }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable {
+      public T Current { get { return default(T); } }
+      object System.Collections.IEnumerator.Current { get { return default(object); } }
+      public void Dispose() { }
+      public bool MoveNext() { return default(bool); }
+      void System.Collections.IEnumerator.Reset() { }
+    }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  public partial class HashSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.ISet<T>, System.Collections.IEnumerable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable {
+    public HashSet() { }
+    public HashSet(System.Collections.Generic.IEnumerable<T> collection) { }
+    public HashSet(System.Collections.Generic.IEnumerable<T> collection, System.Collections.Generic.IEqualityComparer<T> comparer) { }
+    public HashSet(System.Collections.Generic.IEqualityComparer<T> comparer) { }
+    protected HashSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public System.Collections.Generic.IEqualityComparer<T> Comparer { get { return default(System.Collections.Generic.IEqualityComparer<T>); } }
+    public int Count { get { return default(int); } }
+    bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { return default(bool); } }
+    public bool Add(T item) { return default(bool); }
+    public void Clear() { }
+    public bool Contains(T item) { return default(bool); }
+    public void CopyTo(T[] array) { }
+    public void CopyTo(T[] array, int arrayIndex) { }
+    public void CopyTo(T[] array, int arrayIndex, int count) { }
+    public static System.Collections.Generic.IEqualityComparer<System.Collections.Generic.HashSet<T>> CreateSetComparer() { return default(System.Collections.Generic.IEqualityComparer<System.Collections.Generic.HashSet<T>>); }
+    public void ExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
+    public System.Collections.Generic.HashSet<T>.Enumerator GetEnumerator() { return default(System.Collections.Generic.HashSet<T>.Enumerator); }
+    [System.Security.SecurityCriticalAttribute]
+    public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public void IntersectWith(System.Collections.Generic.IEnumerable<T> other) { }
+    public bool IsProperSubsetOf(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public bool IsProperSupersetOf(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public bool IsSubsetOf(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public bool IsSupersetOf(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public virtual void OnDeserialization(object sender) { }
+    public bool Overlaps(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public bool Remove(T item) { return default(bool); }
+    public int RemoveWhere(System.Predicate<T> match) { return default(int); }
+    public bool SetEquals(System.Collections.Generic.IEnumerable<T> other) { return default(bool); }
+    public void SymmetricExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
+    void System.Collections.Generic.ICollection<T>.Add(T item) { }
+    System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public void TrimExcess() { }
+    public void UnionWith(System.Collections.Generic.IEnumerable<T> other) { }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable {
+      public T Current { get { return default(T); } }
+      object System.Collections.IEnumerator.Current { get { return default(object); } }
+      public void Dispose() { }
+      public bool MoveNext() { return default(bool); }
+      void System.Collections.IEnumerator.Reset() { }
+    }
+  }
+
+} // end of System.Collections.Generic

fxdac/fxdac/Data/Contracts/System.ComponentModel.EventBasedAsync.cs

@@ -0,0 +1,83 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.ComponentModel {
+  public partial class AsyncCompletedEventArgs : System.EventArgs {
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+    public AsyncCompletedEventArgs() { }
+    public AsyncCompletedEventArgs(System.Exception error, bool cancelled, object userState) { }
+    public bool Cancelled { get { return default(bool); } }
+    public System.Exception Error { get { return default(System.Exception); } }
+    public object UserState { get { return default(object); } }
+    protected void RaiseExceptionIfNecessary() { }
+  }
+
+  public delegate void AsyncCompletedEventHandler(object sender, System.ComponentModel.AsyncCompletedEventArgs e);
+
+  public sealed partial class AsyncOperation {
+    internal AsyncOperation() { }
+    public System.Threading.SynchronizationContext SynchronizationContext { get { return default(System.Threading.SynchronizationContext); } }
+    public object UserSuppliedState { get { return default(object); } }
+    ~AsyncOperation() { }
+    public void OperationCompleted() { }
+    public void Post(System.Threading.SendOrPostCallback d, object arg) { }
+    public void PostOperationCompleted(System.Threading.SendOrPostCallback d, object arg) { }
+  }
+
+  public static partial class AsyncOperationManager {
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(2))]
+    public static System.Threading.SynchronizationContext SynchronizationContext { get { return default(System.Threading.SynchronizationContext); } set { } }
+    public static System.ComponentModel.AsyncOperation CreateOperation(object userSuppliedState) { return default(System.ComponentModel.AsyncOperation); }
+  }
+
+  [System.ComponentModel.DefaultEventAttribute("DoWork")]
+  public partial class BackgroundWorker {
+    public BackgroundWorker() { }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    public bool CancellationPending { get { return default(bool); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    public bool IsBusy { get { return default(bool); } }
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    public bool WorkerReportsProgress { get { return default(bool); } set { } }
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    public bool WorkerSupportsCancellation { get { return default(bool); } set { } }
+    public event System.ComponentModel.DoWorkEventHandler DoWork { add { } remove { } }
+    public event System.ComponentModel.ProgressChangedEventHandler ProgressChanged { add { } remove { } }
+    public event System.ComponentModel.RunWorkerCompletedEventHandler RunWorkerCompleted { add { } remove { } }
+    public void CancelAsync() { }
+    protected virtual void OnDoWork(System.ComponentModel.DoWorkEventArgs e) { }
+    protected virtual void OnProgressChanged(System.ComponentModel.ProgressChangedEventArgs e) { }
+    protected virtual void OnRunWorkerCompleted(System.ComponentModel.RunWorkerCompletedEventArgs e) { }
+    public void ReportProgress(int percentProgress) { }
+    public void ReportProgress(int percentProgress, object userState) { }
+    public void RunWorkerAsync() { }
+    public void RunWorkerAsync(object argument) { }
+  }
+
+  public delegate void CancelEventHandler(object sender, System.ComponentModel.CancelEventArgs e);
+
+  public partial class DoWorkEventArgs : System.ComponentModel.CancelEventArgs {
+    public DoWorkEventArgs(object argument) { }
+    public object Argument { get { return default(object); } }
+    public object Result { get { return default(object); } set { } }
+  }
+
+  public delegate void DoWorkEventHandler(object sender, System.ComponentModel.DoWorkEventArgs e);
+
+  public partial class ProgressChangedEventArgs : System.EventArgs {
+    public ProgressChangedEventArgs(int progressPercentage, object userState) { }
+    public int ProgressPercentage { get { return default(int); } }
+    public object UserState { get { return default(object); } }
+  }
+
+  public delegate void ProgressChangedEventHandler(object sender, System.ComponentModel.ProgressChangedEventArgs e);
+
+  public partial class RunWorkerCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    public RunWorkerCompletedEventArgs(object result, System.Exception error, bool cancelled) { }
+    public object Result { get { return default(object); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+    public new object UserState { get { return default(object); } }
+  }
+
+  public delegate void RunWorkerCompletedEventHandler(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e);
+
+} // end of System.ComponentModel

fxdac/fxdac/Data/Contracts/System.ComponentModel.cs

@@ -0,0 +1,45 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.ComponentModel {
+  [System.AttributeUsageAttribute((System.AttributeTargets)(32767))]
+  public sealed partial class BrowsableAttribute : System.Attribute {
+    public static readonly System.ComponentModel.BrowsableAttribute Default;
+    public static readonly System.ComponentModel.BrowsableAttribute No;
+    public static readonly System.ComponentModel.BrowsableAttribute Yes;
+    public BrowsableAttribute(bool browsable) { }
+    public bool Browsable { get { return default(bool); } }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override bool IsDefaultAttribute() { return default(bool); }
+  }
+
+  public partial class CancelEventArgs : System.EventArgs {
+    public CancelEventArgs() { }
+    public CancelEventArgs(bool cancel) { }
+    public bool Cancel { get { return default(bool); } set { } }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(4))]
+  public sealed partial class DefaultEventAttribute : System.Attribute {
+    public static readonly System.ComponentModel.DefaultEventAttribute Default;
+    public DefaultEventAttribute(string name) { }
+    public string Name { get { return default(string); } }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+  }
+
+  public partial interface IChangeTracking {
+    bool IsChanged { get; }
+    void AcceptChanges();
+  }
+
+  public partial interface IEditableObject {
+    void BeginEdit();
+    void CancelEdit();
+    void EndEdit();
+  }
+
+  public partial interface IRevertibleChangeTracking : System.ComponentModel.IChangeTracking {
+    void RejectChanges();
+  }
+
+} // end of System.ComponentModel

fxdac/fxdac/Data/Contracts/System.Console.cs

@@ -0,0 +1,262 @@
+[assembly:System.CLSCompliant(true)]
+namespace System {
+  public static partial class Console {
+    public static System.IO.TextWriter Error { get { return default(System.IO.TextWriter); } }
+    public static System.IO.TextReader In { get { return default(System.IO.TextReader); } }
+    public static System.IO.TextWriter Out { get { return default(System.IO.TextWriter); } }
+    public static System.IO.Stream OpenStandardError() { return default(System.IO.Stream); }
+    public static System.IO.Stream OpenStandardError(int bufferSize) { return default(System.IO.Stream); }
+    public static System.IO.Stream OpenStandardInput() { return default(System.IO.Stream); }
+    public static System.IO.Stream OpenStandardInput(int bufferSize) { return default(System.IO.Stream); }
+    public static System.IO.Stream OpenStandardOutput() { return default(System.IO.Stream); }
+    public static System.IO.Stream OpenStandardOutput(int bufferSize) { return default(System.IO.Stream); }
+    public static int Read() { return default(int); }
+    public static string ReadLine() { return default(string); }
+    public static void SetError(System.IO.TextWriter newError) { }
+    public static void SetIn(System.IO.TextReader newIn) { }
+    public static void SetOut(System.IO.TextWriter newOut) { }
+    public static void Write(bool value) { }
+    public static void Write(char value) { }
+    public static void Write(char[] buffer) { }
+    public static void Write(char[] buffer, int index, int count) { }
+    public static void Write(decimal value) { }
+    public static void Write(double value) { }
+    public static void Write(int value) { }
+    public static void Write(long value) { }
+    public static void Write(object value) { }
+    public static void Write(float value) { }
+    public static void Write(string value) { }
+    public static void Write(string format, object arg0) { }
+    public static void Write(string format, object arg0, object arg1) { }
+    public static void Write(string format, object arg0, object arg1, object arg2) { }
+    [System.CLSCompliantAttribute(false)]
+    public static void Write(string format, object arg0, object arg1, object arg2, object arg3, __arglist) { }
+    public static void Write(string format, params object[] arg) { }
+    [System.CLSCompliantAttribute(false)]
+    public static void Write(uint value) { }
+    [System.CLSCompliantAttribute(false)]
+    public static void Write(ulong value) { }
+    public static void WriteLine() { }
+    public static void WriteLine(bool value) { }
+    public static void WriteLine(char value) { }
+    public static void WriteLine(char[] buffer) { }
+    public static void WriteLine(char[] buffer, int index, int count) { }
+    public static void WriteLine(decimal value) { }
+    public static void WriteLine(double value) { }
+    public static void WriteLine(int value) { }
+    public static void WriteLine(long value) { }
+    public static void WriteLine(object value) { }
+    public static void WriteLine(float value) { }
+    public static void WriteLine(string value) { }
+    public static void WriteLine(string format, object arg0) { }
+    public static void WriteLine(string format, object arg0, object arg1) { }
+    public static void WriteLine(string format, object arg0, object arg1, object arg2) { }
+    [System.CLSCompliantAttribute(false)]
+    public static void WriteLine(string format, object arg0, object arg1, object arg2, object arg3, __arglist) { }
+    public static void WriteLine(string format, params object[] arg) { }
+    [System.CLSCompliantAttribute(false)]
+    public static void WriteLine(uint value) { }
+    [System.CLSCompliantAttribute(false)]
+    public static void WriteLine(ulong value) { }
+  }
+
+  public sealed partial class ConsoleCancelEventArgs : System.EventArgs {
+    internal ConsoleCancelEventArgs() { }
+    public bool Cancel { get { return default(bool); } set { } }
+    public System.ConsoleSpecialKey SpecialKey { get { return default(System.ConsoleSpecialKey); } }
+  }
+
+  public delegate void ConsoleCancelEventHandler(object sender, System.ConsoleCancelEventArgs e);
+
+  public enum ConsoleColor {
+    Black = 0,
+    Blue = 9,
+    Cyan = 11,
+    DarkBlue = 1,
+    DarkCyan = 3,
+    DarkGray = 8,
+    DarkGreen = 2,
+    DarkMagenta = 5,
+    DarkRed = 4,
+    DarkYellow = 6,
+    Gray = 7,
+    Green = 10,
+    Magenta = 13,
+    Red = 12,
+    White = 15,
+    Yellow = 14,
+  }
+
+  public enum ConsoleKey {
+    A = 65,
+    Add = 107,
+    Applications = 93,
+    Attention = 246,
+    B = 66,
+    Backspace = 8,
+    BrowserBack = 166,
+    BrowserFavorites = 171,
+    BrowserForward = 167,
+    BrowserHome = 172,
+    BrowserRefresh = 168,
+    BrowserSearch = 170,
+    BrowserStop = 169,
+    C = 67,
+    Clear = 12,
+    CrSel = 247,
+    D = 68,
+    D0 = 48,
+    D1 = 49,
+    D2 = 50,
+    D3 = 51,
+    D4 = 52,
+    D5 = 53,
+    D6 = 54,
+    D7 = 55,
+    D8 = 56,
+    D9 = 57,
+    Decimal = 110,
+    Delete = 46,
+    Divide = 111,
+    DownArrow = 40,
+    E = 69,
+    End = 35,
+    Enter = 13,
+    EraseEndOfFile = 249,
+    Escape = 27,
+    Execute = 43,
+    ExSel = 248,
+    F = 70,
+    F1 = 112,
+    F10 = 121,
+    F11 = 122,
+    F12 = 123,
+    F13 = 124,
+    F14 = 125,
+    F15 = 126,
+    F16 = 127,
+    F17 = 128,
+    F18 = 129,
+    F19 = 130,
+    F2 = 113,
+    F20 = 131,
+    F21 = 132,
+    F22 = 133,
+    F23 = 134,
+    F24 = 135,
+    F3 = 114,
+    F4 = 115,
+    F5 = 116,
+    F6 = 117,
+    F7 = 118,
+    F8 = 119,
+    F9 = 120,
+    G = 71,
+    H = 72,
+    Help = 47,
+    Home = 36,
+    I = 73,
+    Insert = 45,
+    J = 74,
+    K = 75,
+    L = 76,
+    LaunchApp1 = 182,
+    LaunchApp2 = 183,
+    LaunchMail = 180,
+    LaunchMediaSelect = 181,
+    LeftArrow = 37,
+    LeftWindows = 91,
+    M = 77,
+    MediaNext = 176,
+    MediaPlay = 179,
+    MediaPrevious = 177,
+    MediaStop = 178,
+    Multiply = 106,
+    N = 78,
+    NoName = 252,
+    NumPad0 = 96,
+    NumPad1 = 97,
+    NumPad2 = 98,
+    NumPad3 = 99,
+    NumPad4 = 100,
+    NumPad5 = 101,
+    NumPad6 = 102,
+    NumPad7 = 103,
+    NumPad8 = 104,
+    NumPad9 = 105,
+    O = 79,
+    Oem1 = 186,
+    Oem102 = 226,
+    Oem2 = 191,
+    Oem3 = 192,
+    Oem4 = 219,
+    Oem5 = 220,
+    Oem6 = 221,
+    Oem7 = 222,
+    Oem8 = 223,
+    OemClear = 254,
+    OemComma = 188,
+    OemMinus = 189,
+    OemPeriod = 190,
+    OemPlus = 187,
+    P = 80,
+    Pa1 = 253,
+    Packet = 231,
+    PageDown = 34,
+    PageUp = 33,
+    Pause = 19,
+    Play = 250,
+    Print = 42,
+    PrintScreen = 44,
+    Process = 229,
+    Q = 81,
+    R = 82,
+    RightArrow = 39,
+    RightWindows = 92,
+    S = 83,
+    Select = 41,
+    Separator = 108,
+    Sleep = 95,
+    Spacebar = 32,
+    Subtract = 109,
+    T = 84,
+    Tab = 9,
+    U = 85,
+    UpArrow = 38,
+    V = 86,
+    VolumeDown = 174,
+    VolumeMute = 173,
+    VolumeUp = 175,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    Zoom = 251,
+  }
+
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct ConsoleKeyInfo {
+    public ConsoleKeyInfo(char keyChar, System.ConsoleKey key, bool shift, bool alt, bool control) { throw new System.NotImplementedException(); }
+    public System.ConsoleKey Key { get { return default(System.ConsoleKey); } }
+    public char KeyChar { get { return default(char); } }
+    public System.ConsoleModifiers Modifiers { get { return default(System.ConsoleModifiers); } }
+    public bool Equals(System.ConsoleKeyInfo obj) { return default(bool); }
+    public override bool Equals(object value) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public static bool operator ==(System.ConsoleKeyInfo a, System.ConsoleKeyInfo b) { return default(bool); }
+    public static bool operator !=(System.ConsoleKeyInfo a, System.ConsoleKeyInfo b) { return default(bool); }
+  }
+
+  [System.FlagsAttribute]
+  public enum ConsoleModifiers {
+    Alt = 1,
+    Control = 4,
+    Shift = 2,
+  }
+
+  public enum ConsoleSpecialKey {
+    ControlBreak = 1,
+    ControlC = 0,
+  }
+
+} // end of System

fxdac/fxdac/Data/Contracts/System.Deployment.cs

@@ -0,0 +1,19 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Deployment.Internal {
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public static partial class InternalActivationContextHelper {
+    public static object GetActivationContextData(System.ActivationContext appInfo) { return default(object); }
+    public static object GetApplicationComponentManifest(System.ActivationContext appInfo) { return default(object); }
+    public static byte[] GetApplicationManifestBytes(System.ActivationContext appInfo) { return default(byte[]); }
+    public static object GetDeploymentComponentManifest(System.ActivationContext appInfo) { return default(object); }
+    public static byte[] GetDeploymentManifestBytes(System.ActivationContext appInfo) { return default(byte[]); }
+    public static bool IsFirstRun(System.ActivationContext appInfo) { return default(bool); }
+    public static void PrepareForExecution(System.ActivationContext appInfo) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public static partial class InternalApplicationIdentityHelper {
+    public static object GetInternalAppId(System.ApplicationIdentity id) { return default(object); }
+  }
+
+} // end of System.Deployment.Internal

fxdac/fxdac/Data/Contracts/System.Diagnostics.Contracts.cs

@@ -0,0 +1,190 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics.Contracts {
+  public static partial class Contract {
+    public static event System.EventHandler<System.Diagnostics.Contracts.ContractFailedEventArgs> ContractFailed { add { } remove { } }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Assert(bool condition) { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Assert(bool condition, string userMessage) { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Assume(bool condition) { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Assume(bool condition, string userMessage) { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void EndContractBlock() { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Ensures(bool condition) { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Ensures(bool condition, string userMessage) { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void EnsuresOnThrow<TException>(bool condition) where TException : System.Exception { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void EnsuresOnThrow<TException>(bool condition, string userMessage) where TException : System.Exception { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static bool Exists(int fromInclusive, int toExclusive, System.Predicate<int> predicate) { return default(bool); }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static bool Exists<T>(System.Collections.Generic.IEnumerable<T> collection, System.Predicate<T> predicate) { return default(bool); }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static bool ForAll(int fromInclusive, int toExclusive, System.Predicate<int> predicate) { return default(bool); }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static bool ForAll<T>(System.Collections.Generic.IEnumerable<T> collection, System.Predicate<T> predicate) { return default(bool); }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Invariant(bool condition) { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Invariant(bool condition, string userMessage) { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static T OldValue<T>(T value) { return default(T); }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Requires(bool condition) { }
+    [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Requires(bool condition, string userMessage) { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Requires<TException>(bool condition) where TException : System.Exception { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void Requires<TException>(bool condition, string userMessage) where TException : System.Exception { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static T Result<T>() { return default(T); }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static T ValueAtReturn<T>(out T value) { value = default(T); return default(T); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(64), AllowMultiple=false)]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class ContractAbbreviatorAttribute : System.Attribute {
+    public ContractAbbreviatorAttribute() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(64), AllowMultiple=false)]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class ContractArgumentValidatorAttribute : System.Attribute {
+    public ContractArgumentValidatorAttribute() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(5124), AllowMultiple=false, Inherited=false)]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  [System.Diagnostics.ConditionalAttribute("DEBUG")]
+  public sealed partial class ContractClassAttribute : System.Attribute {
+    public ContractClassAttribute(System.Type typeContainingContracts) { }
+    public System.Type TypeContainingContracts { get { return default(System.Type); } }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(4), AllowMultiple=false, Inherited=false)]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class ContractClassForAttribute : System.Attribute {
+    public ContractClassForAttribute(System.Type typeContractsAreFor) { }
+    public System.Type TypeContractsAreFor { get { return default(System.Type); } }
+  }
+
+  public sealed partial class ContractFailedEventArgs : System.EventArgs {
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public ContractFailedEventArgs(System.Diagnostics.Contracts.ContractFailureKind failureKind, string message, string condition, System.Exception originalException) { }
+    public string Condition { get { return default(string); } }
+    public System.Diagnostics.Contracts.ContractFailureKind FailureKind { get { return default(System.Diagnostics.Contracts.ContractFailureKind); } }
+    public bool Handled { get { return default(bool); } }
+    public string Message { get { return default(string); } }
+    public System.Exception OriginalException { get { return default(System.Exception); } }
+    public bool Unwind { get { return default(bool); } }
+    [System.Security.SecurityCriticalAttribute]
+    public void SetHandled() { }
+    [System.Security.SecurityCriticalAttribute]
+    public void SetUnwind() { }
+  }
+
+  public enum ContractFailureKind {
+    Assert = 4,
+    Assume = 5,
+    Invariant = 3,
+    Postcondition = 1,
+    PostconditionOnException = 2,
+    Precondition = 0,
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(64), AllowMultiple=false, Inherited=false)]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class ContractInvariantMethodAttribute : System.Attribute {
+    public ContractInvariantMethodAttribute() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(32767), AllowMultiple=true, Inherited=false)]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class ContractOptionAttribute : System.Attribute {
+    public ContractOptionAttribute(string category, string setting, bool enabled) { }
+    public ContractOptionAttribute(string category, string setting, string value) { }
+    public string Category { get { return default(string); } }
+    public bool Enabled { get { return default(bool); } }
+    public string Setting { get { return default(string); } }
+    public string Value { get { return default(string); } }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(256))]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class ContractPublicPropertyNameAttribute : System.Attribute {
+    public ContractPublicPropertyNameAttribute(string name) { }
+    public string Name { get { return default(string); } }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(1))]
+  public sealed partial class ContractReferenceAssemblyAttribute : System.Attribute {
+    public ContractReferenceAssemblyAttribute() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(192), AllowMultiple=false, Inherited=true)]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class ContractRuntimeIgnoredAttribute : System.Attribute {
+    public ContractRuntimeIgnoredAttribute() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(237))]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class ContractVerificationAttribute : System.Attribute {
+    public ContractVerificationAttribute(bool value) { }
+    public bool Value { get { return default(bool); } }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(6884), AllowMultiple=false, Inherited=true)]
+  [System.Diagnostics.ConditionalAttribute("CONTRACTS_FULL")]
+  public sealed partial class PureAttribute : System.Attribute {
+    public PureAttribute() { }
+  }
+
+} // end of System.Diagnostics.Contracts
+namespace System.Diagnostics.Contracts.Internal {
+  [System.ObsoleteAttribute("Use the ContractHelper class in the System.Runtime.CompilerServices namespace instead.")]
+  public static partial class ContractHelper {
+    [System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static string RaiseContractFailedEvent(System.Diagnostics.Contracts.ContractFailureKind failureKind, string userMessage, string conditionText, System.Exception innerException) { return default(string); }
+    [System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void TriggerFailure(System.Diagnostics.Contracts.ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, System.Exception innerException) { }
+  }
+
+} // end of System.Diagnostics.Contracts.Internal
+namespace System.Runtime.CompilerServices {
+  public static partial class ContractHelper {
+    [System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static string RaiseContractFailedEvent(System.Diagnostics.Contracts.ContractFailureKind failureKind, string userMessage, string conditionText, System.Exception innerException) { return default(string); }
+    [System.Diagnostics.DebuggerNonUserCodeAttribute]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void TriggerFailure(System.Diagnostics.Contracts.ContractFailureKind kind, string displayMessage, string userMessage, string conditionText, System.Exception innerException) { }
+  }
+
+} // end of System.Runtime.CompilerServices

fxdac/fxdac/Data/Contracts/System.Diagnostics.Debug.cs

@@ -0,0 +1,38 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Debugger {
+    public static readonly string DefaultCategory;
+    [System.ObsoleteAttribute("Call the static methods directly on this type", true)]
+    public Debugger() { }
+    public static bool IsAttached { get { return default(bool); } }
+    public static void Break() { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static bool IsLogging() { return default(bool); }
+    public static bool Launch() { return default(bool); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void Log(int level, string category, string message) { }
+    public static void NotifyOfCrossThreadDependency() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(96), Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class DebuggerStepperBoundaryAttribute : System.Attribute {
+    public DebuggerStepperBoundaryAttribute() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(13), AllowMultiple=true)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class DebuggerVisualizerAttribute : System.Attribute {
+    public DebuggerVisualizerAttribute(string visualizerTypeName) { }
+    public DebuggerVisualizerAttribute(string visualizerTypeName, string visualizerObjectSourceTypeName) { }
+    public DebuggerVisualizerAttribute(string visualizerTypeName, System.Type visualizerObjectSource) { }
+    public DebuggerVisualizerAttribute(System.Type visualizer) { }
+    public DebuggerVisualizerAttribute(System.Type visualizer, string visualizerObjectSourceTypeName) { }
+    public DebuggerVisualizerAttribute(System.Type visualizer, System.Type visualizerObjectSource) { }
+    public string Description { get { return default(string); } set { } }
+    public System.Type Target { get { return default(System.Type); } set { } }
+    public string TargetTypeName { get { return default(string); } set { } }
+    public string VisualizerObjectSourceTypeName { get { return default(string); } }
+    public string VisualizerTypeName { get { return default(string); } }
+  }
+
+} // end of System.Diagnostics

fxdac/fxdac/Data/Contracts/System.Diagnostics.FileVersionInfo.cs

@@ -0,0 +1,36 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics {
+  public sealed partial class FileVersionInfo {
+    internal FileVersionInfo() { }
+    public string Comments { get { return default(string); } }
+    public string CompanyName { get { return default(string); } }
+    public int FileBuildPart { get { return default(int); } }
+    public string FileDescription { get { return default(string); } }
+    public int FileMajorPart { get { return default(int); } }
+    public int FileMinorPart { get { return default(int); } }
+    public string FileName { get { return default(string); } }
+    public int FilePrivatePart { get { return default(int); } }
+    public string FileVersion { get { return default(string); } }
+    public string InternalName { get { return default(string); } }
+    public bool IsDebug { get { return default(bool); } }
+    public bool IsPatched { get { return default(bool); } }
+    public bool IsPreRelease { get { return default(bool); } }
+    public bool IsPrivateBuild { get { return default(bool); } }
+    public bool IsSpecialBuild { get { return default(bool); } }
+    public string Language { get { return default(string); } }
+    public string LegalCopyright { get { return default(string); } }
+    public string LegalTrademarks { get { return default(string); } }
+    public string OriginalFilename { get { return default(string); } }
+    public string PrivateBuild { get { return default(string); } }
+    public int ProductBuildPart { get { return default(int); } }
+    public int ProductMajorPart { get { return default(int); } }
+    public int ProductMinorPart { get { return default(int); } }
+    public string ProductName { get { return default(string); } }
+    public int ProductPrivatePart { get { return default(int); } }
+    public string ProductVersion { get { return default(string); } }
+    public string SpecialBuild { get { return default(string); } }
+    public static System.Diagnostics.FileVersionInfo GetVersionInfo(string fileName) { return default(System.Diagnostics.FileVersionInfo); }
+    public override string ToString() { return default(string); }
+  }
+
+} // end of System.Diagnostics

fxdac/fxdac/Data/Contracts/System.Diagnostics.Process.cs

@@ -0,0 +1,396 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics {
+  public partial class DataReceivedEventArgs : System.EventArgs {
+    internal DataReceivedEventArgs() { }
+    public string Data { get { return default(string); } }
+  }
+
+  public delegate void DataReceivedEventHandler(object sender, System.Diagnostics.DataReceivedEventArgs e);
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(32767))]
+  public partial class MonitoringDescriptionAttribute : System.ComponentModel.DescriptionAttribute {
+    public MonitoringDescriptionAttribute(string description) { }
+    public override string Description { get { return default(string); } }
+  }
+
+  [System.ComponentModel.DefaultEventAttribute("Exited")]
+  [System.ComponentModel.DefaultPropertyAttribute("StartInfo")]
+  [System.ComponentModel.DesignerAttribute("System.Diagnostics.Design.ProcessDesigner, System.Design, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+  [System.Diagnostics.MonitoringDescriptionAttribute("Represents a system process")]
+  public partial class Process : System.ComponentModel.Component {
+    public Process() { }
+    [System.Diagnostics.MonitoringDescriptionAttribute("Base process priority.")]
+    public int BasePriority { get { return default(int); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Check for exiting of the process to raise the apropriate event.")]
+    public bool EnableRaisingEvents { get { return default(bool); } set { } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The exit code of the process.")]
+    public int ExitCode { get { return default(int); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The exit time of the process.")]
+    public System.DateTime ExitTime { get { return default(System.DateTime); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Handle for this process.")]
+    public System.IntPtr Handle { get { return default(System.IntPtr); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("Handles for this process.")]
+    public int HandleCount { get { return default(int); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Determines if the process is still running.")]
+    public bool HasExited { get { return default(bool); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("Process identifier.")]
+    public int Id { get { return default(int); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The name of the computer running the process.")]
+    public string MachineName { get { return default(string); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The main module of the process.")]
+    public System.Diagnostics.ProcessModule MainModule { get { return default(System.Diagnostics.ProcessModule); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The handle of the main window of the process.")]
+    public System.IntPtr MainWindowHandle { get { return default(System.IntPtr); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The title of the main window of the process.")]
+    public string MainWindowTitle { get { return default(string); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The maximum working set for this process.")]
+    public System.IntPtr MaxWorkingSet { get { return default(System.IntPtr); } set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The minimum working set for this process.")]
+    public System.IntPtr MinWorkingSet { get { return default(System.IntPtr); } set { } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The modules that are loaded as part of this process.")]
+    public System.Diagnostics.ProcessModuleCollection Modules { get { return default(System.Diagnostics.ProcessModuleCollection); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The number of bytes that are not pageable.")]
+    [System.ObsoleteAttribute("Use NonpagedSystemMemorySize64")]
+    public int NonpagedSystemMemorySize { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The number of bytes that are not pageable.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long NonpagedSystemMemorySize64 { get { return default(long); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The number of bytes that are paged.")]
+    [System.ObsoleteAttribute("Use PagedMemorySize64")]
+    public int PagedMemorySize { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The number of bytes that are paged.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long PagedMemorySize64 { get { return default(long); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of paged system memory in bytes.")]
+    [System.ObsoleteAttribute("Use PagedSystemMemorySize64")]
+    public int PagedSystemMemorySize { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of paged system memory in bytes.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long PagedSystemMemorySize64 { get { return default(long); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The maximum amount of paged memory used by this process.")]
+    [System.ObsoleteAttribute("Use PeakPagedMemorySize64")]
+    public int PeakPagedMemorySize { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The maximum amount of paged memory used by this process.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long PeakPagedMemorySize64 { get { return default(long); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The maximum amount of virtual memory used by this process.")]
+    [System.ObsoleteAttribute("Use PeakVirtualMemorySize64")]
+    public int PeakVirtualMemorySize { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The maximum amount of virtual memory used by this process.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long PeakVirtualMemorySize64 { get { return default(long); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The maximum amount of system memory used by this process.")]
+    [System.ObsoleteAttribute("Use PeakWorkingSet64")]
+    public int PeakWorkingSet { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The maximum amount of system memory used by this process.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long PeakWorkingSet64 { get { return default(long); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("Process will be of higher priority while it is actively used.")]
+    public bool PriorityBoostEnabled { get { return default(bool); } set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The relative process priority.")]
+    public System.Diagnostics.ProcessPriorityClass PriorityClass { get { return default(System.Diagnostics.ProcessPriorityClass); } set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of memory exclusively used by this process.")]
+    [System.ObsoleteAttribute("Use PrivateMemorySize64")]
+    public int PrivateMemorySize { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of memory exclusively used by this process.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long PrivateMemorySize64 { get { return default(long); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of processing time spent in the OS core for this process.")]
+    public System.TimeSpan PrivilegedProcessorTime { get { return default(System.TimeSpan); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The name of this process.")]
+    public string ProcessName { get { return default(string); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("Allowed processor that can be used by this process.")]
+    public System.IntPtr ProcessorAffinity { get { return default(System.IntPtr); } set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("Is this process responsive.")]
+    public bool Responding { get { return default(bool); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The session ID for this process.")]
+    public int SessionId { get { return default(int); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The standard error stream of this process.")]
+    public System.IO.StreamReader StandardError { get { return default(System.IO.StreamReader); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The standard input stream of this process.")]
+    public System.IO.StreamWriter StandardInput { get { return default(System.IO.StreamWriter); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The standard output stream of this process.")]
+    public System.IO.StreamReader StandardOutput { get { return default(System.IO.StreamReader); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Information for the start of this process.")]
+    public System.Diagnostics.ProcessStartInfo StartInfo { get { return default(System.Diagnostics.ProcessStartInfo); } set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The time this process started.")]
+    public System.DateTime StartTime { get { return default(System.DateTime); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.ComponentModel.DefaultValueAttribute(null)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The object that is used to synchronize event handler calls for this process.")]
+    public System.ComponentModel.ISynchronizeInvoke SynchronizingObject { get { return default(System.ComponentModel.ISynchronizeInvoke); } set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The number of threads of this process.")]
+    public System.Diagnostics.ProcessThreadCollection Threads { get { return default(System.Diagnostics.ProcessThreadCollection); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The total CPU time spent for this process.")]
+    public System.TimeSpan TotalProcessorTime { get { return default(System.TimeSpan); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The CPU time spent for this process in user mode.")]
+    public System.TimeSpan UserProcessorTime { get { return default(System.TimeSpan); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of virtual memory currently used for this process.")]
+    [System.ObsoleteAttribute("Use VirtualMemorySize64")]
+    public int VirtualMemorySize { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of virtual memory currently used for this process.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long VirtualMemorySize64 { get { return default(long); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of physical memory currently used for this process.")]
+    [System.ObsoleteAttribute("Use WorkingSet64")]
+    public int WorkingSet { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of physical memory currently used for this process.")]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public long WorkingSet64 { get { return default(long); } }
+    [System.ComponentModel.BrowsableAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Raised when it receives error data")]
+    public event System.Diagnostics.DataReceivedEventHandler ErrorDataReceived { add { } remove { } }
+    [System.ComponentModel.CategoryAttribute("Behavior")]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Raised when this process exits.")]
+    public event System.EventHandler Exited { add { } remove { } }
+    [System.ComponentModel.BrowsableAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Raised when it receives output data")]
+    public event System.Diagnostics.DataReceivedEventHandler OutputDataReceived { add { } remove { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void BeginErrorReadLine() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void BeginOutputReadLine() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void CancelErrorRead() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void CancelOutputRead() { }
+    public void Close() { }
+    public bool CloseMainWindow() { return default(bool); }
+    protected override void Dispose(bool disposing) { }
+    public static void EnterDebugMode() { }
+    ~Process() { }
+    public static System.Diagnostics.Process GetCurrentProcess() { return default(System.Diagnostics.Process); }
+    public static System.Diagnostics.Process GetProcessById(int processId) { return default(System.Diagnostics.Process); }
+    public static System.Diagnostics.Process GetProcessById(int processId, string machineName) { return default(System.Diagnostics.Process); }
+    public static System.Diagnostics.Process[] GetProcesses() { return default(System.Diagnostics.Process[]); }
+    public static System.Diagnostics.Process[] GetProcesses(string machineName) { return default(System.Diagnostics.Process[]); }
+    public static System.Diagnostics.Process[] GetProcessesByName(string processName) { return default(System.Diagnostics.Process[]); }
+    public static System.Diagnostics.Process[] GetProcessesByName(string processName, string machineName) { return default(System.Diagnostics.Process[]); }
+    public void Kill() { }
+    public static void LeaveDebugMode() { }
+    protected void OnExited() { }
+    public void Refresh() { }
+    public bool Start() { return default(bool); }
+    public static System.Diagnostics.Process Start(System.Diagnostics.ProcessStartInfo startInfo) { return default(System.Diagnostics.Process); }
+    public static System.Diagnostics.Process Start(string fileName) { return default(System.Diagnostics.Process); }
+    public static System.Diagnostics.Process Start(string fileName, string arguments) { return default(System.Diagnostics.Process); }
+    public static System.Diagnostics.Process Start(string fileName, string username, System.Security.SecureString password, string domain) { return default(System.Diagnostics.Process); }
+    public static System.Diagnostics.Process Start(string fileName, string arguments, string username, System.Security.SecureString password, string domain) { return default(System.Diagnostics.Process); }
+    public override string ToString() { return default(string); }
+    public void WaitForExit() { }
+    public bool WaitForExit(int milliseconds) { return default(bool); }
+    public bool WaitForInputIdle() { return default(bool); }
+    public bool WaitForInputIdle(int milliseconds) { return default(bool); }
+  }
+
+  [System.ComponentModel.DesignerAttribute("System.Diagnostics.Design.ProcessModuleDesigner, System.Design, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+  public partial class ProcessModule : System.ComponentModel.Component {
+    internal ProcessModule() { }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The base memory address of this module")]
+    public System.IntPtr BaseAddress { get { return default(System.IntPtr); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The base memory address of the entry point of this module")]
+    public System.IntPtr EntryPointAddress { get { return default(System.IntPtr); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The file name of this module")]
+    public string FileName { get { return default(string); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    public System.Diagnostics.FileVersionInfo FileVersionInfo { get { return default(System.Diagnostics.FileVersionInfo); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The memory needed by this module")]
+    public int ModuleMemorySize { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The name of this module")]
+    public string ModuleName { get { return default(string); } }
+    public override string ToString() { return default(string); }
+  }
+
+  public partial class ProcessModuleCollection : System.Diagnostics.ProcessModuleCollectionBase {
+    protected ProcessModuleCollection() { }
+    public ProcessModuleCollection(System.Diagnostics.ProcessModule[] processModules) { }
+  }
+
+  public partial class ProcessModuleCollectionBase : System.Collections.Generic.List<System.Diagnostics.ProcessModule> {
+    public ProcessModuleCollectionBase() { }
+    protected System.Diagnostics.ProcessModuleCollectionBase InnerList { get { return default(System.Diagnostics.ProcessModuleCollectionBase); } }
+  }
+
+  public enum ProcessPriorityClass {
+    AboveNormal = 32768,
+    BelowNormal = 16384,
+    High = 128,
+    Idle = 64,
+    Normal = 32,
+    RealTime = 256,
+  }
+
+  public sealed partial class ProcessStartInfo {
+    public ProcessStartInfo() { }
+    public ProcessStartInfo(string filename) { }
+    public ProcessStartInfo(string filename, string arguments) { }
+    [System.ComponentModel.DefaultValueAttribute("")]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Command line agruments for this process.")]
+    public string Arguments { get { return default(string); } set { } }
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Start this process with a new window.")]
+    public bool CreateNoWindow { get { return default(bool); } set { } }
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    public string Domain { get { return default(string); } set { } }
+    [System.ComponentModel.DefaultValueAttribute(null)]
+    [System.ComponentModel.EditorAttribute("System.Diagnostics.Design.StringDictionaryEditor, System.Design, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Environment variables used for this process.")]
+    public System.Collections.Specialized.StringDictionary EnvironmentVariables { get { return default(System.Collections.Specialized.StringDictionary); } }
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Thread shows dialogboxes for errors.")]
+    public bool ErrorDialog { get { return default(bool); } set { } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    public System.IntPtr ErrorDialogParentHandle { get { return default(System.IntPtr); } set { } }
+    [System.ComponentModel.DefaultValueAttribute("")]
+    [System.ComponentModel.EditorAttribute("System.Diagnostics.Design.StartFileNameEditor, System.Design, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The name of the resource to start this process.")]
+    public string FileName { get { return default(string); } set { } }
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    public bool LoadUserProfile { get { return default(bool); } set { } }
+    public System.Security.SecureString Password { get { return default(System.Security.SecureString); } set { } }
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Errors of this process are redirected.")]
+    public bool RedirectStandardError { get { return default(bool); } set { } }
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Standard input of this process is redirected.")]
+    public bool RedirectStandardInput { get { return default(bool); } set { } }
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Standard output of this process is redirected.")]
+    public bool RedirectStandardOutput { get { return default(bool); } set { } }
+    public System.Text.Encoding StandardErrorEncoding { get { return default(System.Text.Encoding); } set { } }
+    public System.Text.Encoding StandardOutputEncoding { get { return default(System.Text.Encoding); } set { } }
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    public string UserName { get { return default(string); } set { } }
+    [System.ComponentModel.DefaultValueAttribute(true)]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("Use the shell to start this process.")]
+    public bool UseShellExecute { get { return default(bool); } set { } }
+    [System.ComponentModel.DefaultValueAttribute("")]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The verb to apply to a used document.")]
+    public string Verb { get { return default(string); } set { } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    public string[] Verbs { get { return default(string[]); } }
+    [System.ComponentModel.DefaultValueAttribute(typeof(System.Diagnostics.ProcessWindowStyle), "Normal")]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The window style used to start this process.")]
+    public System.Diagnostics.ProcessWindowStyle WindowStyle { get { return default(System.Diagnostics.ProcessWindowStyle); } set { } }
+    [System.ComponentModel.DefaultValueAttribute("")]
+    [System.ComponentModel.EditorAttribute("System.Diagnostics.Design.WorkingDirectoryEditor, System.Design, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+    [System.ComponentModel.NotifyParentPropertyAttribute(true)]
+    [System.Diagnostics.MonitoringDescriptionAttribute("The initial directory for this process.")]
+    public string WorkingDirectory { get { return default(string); } set { } }
+  }
+
+  [System.ComponentModel.DesignerAttribute("System.Diagnostics.Design.ProcessThreadDesigner, System.Design, Version=2.0.5.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+  public partial class ProcessThread : System.ComponentModel.Component {
+    internal ProcessThread() { }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The base priority of this thread.")]
+    public int BasePriority { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The current priority of this thread.")]
+    public int CurrentPriority { get { return default(int); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The ID of this thread.")]
+    public int Id { get { return default(int); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    public int IdealProcessor { set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("Thread gets a priority boot when interactively used by a user.")]
+    public bool PriorityBoostEnabled { get { return default(bool); } set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The priority level of this thread.")]
+    public System.Diagnostics.ThreadPriorityLevel PriorityLevel { get { return default(System.Diagnostics.ThreadPriorityLevel); } set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of CPU time used in privileged mode.")]
+    public System.TimeSpan PrivilegedProcessorTime { get { return default(System.TimeSpan); } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    public System.IntPtr ProcessorAffinity { set { } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The start address in memory of this thread.")]
+    public System.IntPtr StartAddress { get { return default(System.IntPtr); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The time this thread was started.")]
+    public System.DateTime StartTime { get { return default(System.DateTime); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The current state of this thread.")]
+    public System.Diagnostics.ThreadState ThreadState { get { return default(System.Diagnostics.ThreadState); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The total amount of CPU time used.")]
+    public System.TimeSpan TotalProcessorTime { get { return default(System.TimeSpan); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The amount of CPU time used in user mode.")]
+    public System.TimeSpan UserProcessorTime { get { return default(System.TimeSpan); } }
+    [System.Diagnostics.MonitoringDescriptionAttribute("The reason why this thread is waiting.")]
+    public System.Diagnostics.ThreadWaitReason WaitReason { get { return default(System.Diagnostics.ThreadWaitReason); } }
+    public void ResetIdealProcessor() { }
+  }
+
+  public partial class ProcessThreadCollection : System.Diagnostics.ProcessThreadCollectionBase {
+    protected ProcessThreadCollection() { }
+    public ProcessThreadCollection(System.Diagnostics.ProcessThread[] processThreads) { }
+  }
+
+  public partial class ProcessThreadCollectionBase : System.Collections.Generic.List<System.Diagnostics.ProcessThread> {
+    public ProcessThreadCollectionBase() { }
+    protected System.Diagnostics.ProcessThreadCollectionBase InnerList { get { return default(System.Diagnostics.ProcessThreadCollectionBase); } }
+    public new int Add(System.Diagnostics.ProcessThread thread) { return default(int); }
+  }
+
+  public enum ProcessWindowStyle {
+    Hidden = 1,
+    Maximized = 3,
+    Minimized = 2,
+    Normal = 0,
+  }
+
+  public enum ThreadPriorityLevel {
+    AboveNormal = 1,
+    BelowNormal = -1,
+    Highest = 2,
+    Idle = -15,
+    Lowest = -2,
+    Normal = 0,
+    TimeCritical = 15,
+  }
+
+  public enum ThreadState {
+    Initialized = 0,
+    Ready = 1,
+    Running = 2,
+    Standby = 3,
+    Terminated = 4,
+    Transition = 6,
+    Unknown = 7,
+    Wait = 5,
+  }
+
+  public enum ThreadWaitReason {
+    EventPairHigh = 7,
+    EventPairLow = 8,
+    ExecutionDelay = 4,
+    Executive = 0,
+    FreePage = 1,
+    LpcReceive = 9,
+    LpcReply = 10,
+    PageIn = 2,
+    PageOut = 12,
+    Suspended = 5,
+    SystemAllocation = 3,
+    Unknown = 13,
+    UserRequest = 6,
+    VirtualMemory = 11,
+  }
+
+} // end of System.Diagnostics

fxdac/fxdac/Data/Contracts/System.Diagnostics.StackTrace.cs

@@ -0,0 +1,42 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class StackFrame {
+    public const int OFFSET_UNKNOWN = -1;
+    public StackFrame() { }
+    public StackFrame(bool fNeedFileInfo) { }
+    public StackFrame(int skipFrames) { }
+    public StackFrame(int skipFrames, bool fNeedFileInfo) { }
+    public StackFrame(string fileName, int lineNumber) { }
+    public StackFrame(string fileName, int lineNumber, int colNumber) { }
+    public virtual int GetFileColumnNumber() { return default(int); }
+    public virtual int GetFileLineNumber() { return default(int); }
+    public virtual string GetFileName() { return default(string); }
+    public virtual int GetILOffset() { return default(int); }
+    public virtual System.Reflection.MethodBase GetMethod() { return default(System.Reflection.MethodBase); }
+    public virtual int GetNativeOffset() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class StackTrace {
+    public const int METHODS_TO_SKIP = 0;
+    public StackTrace() { }
+    public StackTrace(bool fNeedFileInfo) { }
+    public StackTrace(System.Diagnostics.StackFrame frame) { }
+    public StackTrace(System.Exception e) { }
+    public StackTrace(System.Exception e, bool fNeedFileInfo) { }
+    public StackTrace(System.Exception e, int skipFrames) { }
+    public StackTrace(System.Exception e, int skipFrames, bool fNeedFileInfo) { }
+    public StackTrace(int skipFrames) { }
+    public StackTrace(int skipFrames, bool fNeedFileInfo) { }
+    [System.ObsoleteAttribute]
+    public StackTrace(System.Threading.Thread targetThread, bool needFileInfo) { }
+    public virtual int FrameCount { get { return default(int); } }
+    public virtual System.Diagnostics.StackFrame GetFrame(int index) { return default(System.Diagnostics.StackFrame); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Diagnostics.StackFrame[] GetFrames() { return default(System.Diagnostics.StackFrame[]); }
+    public override string ToString() { return default(string); }
+  }
+
+} // end of System.Diagnostics

fxdac/fxdac/Data/Contracts/System.Diagnostics.SymbolStore.cs

@@ -0,0 +1,171 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics.SymbolStore {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolBinder {
+    [System.ObsoleteAttribute("This interface is not 64-bit clean.  Use ISymbolBinder1 instead")]
+    System.Diagnostics.SymbolStore.ISymbolReader GetReader(int importer, string filename, string searchPath);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolBinder1 {
+    System.Diagnostics.SymbolStore.ISymbolReader GetReader(System.IntPtr importer, string filename, string searchPath);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolDocument {
+    System.Guid CheckSumAlgorithmId { get; }
+    System.Guid DocumentType { get; }
+    bool HasEmbeddedSource { get; }
+    System.Guid Language { get; }
+    System.Guid LanguageVendor { get; }
+    int SourceLength { get; }
+    string URL { get; }
+    int FindClosestLine(int line);
+    byte[] GetCheckSum();
+    byte[] GetSourceRange(int startLine, int startColumn, int endLine, int endColumn);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolDocumentWriter {
+    void SetCheckSum(System.Guid algorithmId, byte[] checkSum);
+    void SetSource(byte[] source);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolMethod {
+    System.Diagnostics.SymbolStore.ISymbolScope RootScope { get; }
+    int SequencePointCount { get; }
+    System.Diagnostics.SymbolStore.SymbolToken Token { get; }
+    System.Diagnostics.SymbolStore.ISymbolNamespace GetNamespace();
+    int GetOffset(System.Diagnostics.SymbolStore.ISymbolDocument document, int line, int column);
+    System.Diagnostics.SymbolStore.ISymbolVariable[] GetParameters();
+    int[] GetRanges(System.Diagnostics.SymbolStore.ISymbolDocument document, int line, int column);
+    System.Diagnostics.SymbolStore.ISymbolScope GetScope(int offset);
+    void GetSequencePoints(int[] offsets, System.Diagnostics.SymbolStore.ISymbolDocument[] documents, int[] lines, int[] columns, int[] endLines, int[] endColumns);
+    bool GetSourceStartEnd(System.Diagnostics.SymbolStore.ISymbolDocument[] docs, int[] lines, int[] columns);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolNamespace {
+    string Name { get; }
+    System.Diagnostics.SymbolStore.ISymbolNamespace[] GetNamespaces();
+    System.Diagnostics.SymbolStore.ISymbolVariable[] GetVariables();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolReader {
+    System.Diagnostics.SymbolStore.SymbolToken UserEntryPoint { get; }
+    System.Diagnostics.SymbolStore.ISymbolDocument GetDocument(string url, System.Guid language, System.Guid languageVendor, System.Guid documentType);
+    System.Diagnostics.SymbolStore.ISymbolDocument[] GetDocuments();
+    System.Diagnostics.SymbolStore.ISymbolVariable[] GetGlobalVariables();
+    System.Diagnostics.SymbolStore.ISymbolMethod GetMethod(System.Diagnostics.SymbolStore.SymbolToken method);
+    System.Diagnostics.SymbolStore.ISymbolMethod GetMethod(System.Diagnostics.SymbolStore.SymbolToken method, int version);
+    System.Diagnostics.SymbolStore.ISymbolMethod GetMethodFromDocumentPosition(System.Diagnostics.SymbolStore.ISymbolDocument document, int line, int column);
+    System.Diagnostics.SymbolStore.ISymbolNamespace[] GetNamespaces();
+    byte[] GetSymAttribute(System.Diagnostics.SymbolStore.SymbolToken parent, string name);
+    System.Diagnostics.SymbolStore.ISymbolVariable[] GetVariables(System.Diagnostics.SymbolStore.SymbolToken parent);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolScope {
+    int EndOffset { get; }
+    System.Diagnostics.SymbolStore.ISymbolMethod Method { get; }
+    System.Diagnostics.SymbolStore.ISymbolScope Parent { get; }
+    int StartOffset { get; }
+    System.Diagnostics.SymbolStore.ISymbolScope[] GetChildren();
+    System.Diagnostics.SymbolStore.ISymbolVariable[] GetLocals();
+    System.Diagnostics.SymbolStore.ISymbolNamespace[] GetNamespaces();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolVariable {
+    int AddressField1 { get; }
+    int AddressField2 { get; }
+    int AddressField3 { get; }
+    System.Diagnostics.SymbolStore.SymAddressKind AddressKind { get; }
+    object Attributes { get; }
+    int EndOffset { get; }
+    string Name { get; }
+    int StartOffset { get; }
+    byte[] GetSignature();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ISymbolWriter {
+    void Close();
+    void CloseMethod();
+    void CloseNamespace();
+    void CloseScope(int endOffset);
+    System.Diagnostics.SymbolStore.ISymbolDocumentWriter DefineDocument(string url, System.Guid language, System.Guid languageVendor, System.Guid documentType);
+    void DefineField(System.Diagnostics.SymbolStore.SymbolToken parent, string name, System.Reflection.FieldAttributes attributes, byte[] signature, System.Diagnostics.SymbolStore.SymAddressKind addrKind, int addr1, int addr2, int addr3);
+    void DefineGlobalVariable(string name, System.Reflection.FieldAttributes attributes, byte[] signature, System.Diagnostics.SymbolStore.SymAddressKind addrKind, int addr1, int addr2, int addr3);
+    void DefineLocalVariable(string name, System.Reflection.FieldAttributes attributes, byte[] signature, System.Diagnostics.SymbolStore.SymAddressKind addrKind, int addr1, int addr2, int addr3, int startOffset, int endOffset);
+    void DefineParameter(string name, System.Reflection.ParameterAttributes attributes, int sequence, System.Diagnostics.SymbolStore.SymAddressKind addrKind, int addr1, int addr2, int addr3);
+    void DefineSequencePoints(System.Diagnostics.SymbolStore.ISymbolDocumentWriter document, int[] offsets, int[] lines, int[] columns, int[] endLines, int[] endColumns);
+    void Initialize(System.IntPtr emitter, string filename, bool fFullBuild);
+    void OpenMethod(System.Diagnostics.SymbolStore.SymbolToken method);
+    void OpenNamespace(string name);
+    int OpenScope(int startOffset);
+    void SetMethodSourceRange(System.Diagnostics.SymbolStore.ISymbolDocumentWriter startDoc, int startLine, int startColumn, System.Diagnostics.SymbolStore.ISymbolDocumentWriter endDoc, int endLine, int endColumn);
+    void SetScopeRange(int scopeID, int startOffset, int endOffset);
+    void SetSymAttribute(System.Diagnostics.SymbolStore.SymbolToken parent, string name, byte[] data);
+    void SetUnderlyingWriter(System.IntPtr underlyingWriter);
+    void SetUserEntryPoint(System.Diagnostics.SymbolStore.SymbolToken entryMethod);
+    void UsingNamespace(string fullName);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum SymAddressKind {
+    BitField = 9,
+    ILOffset = 1,
+    NativeOffset = 5,
+    NativeRegister = 3,
+    NativeRegisterRegister = 6,
+    NativeRegisterRelative = 4,
+    NativeRegisterStack = 7,
+    NativeRVA = 2,
+    NativeSectionOffset = 10,
+    NativeStackRegister = 8,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct SymbolToken {
+    public SymbolToken(int val) { throw new System.NotImplementedException(); }
+    public bool Equals(System.Diagnostics.SymbolStore.SymbolToken obj) { return default(bool); }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public int GetToken() { return default(int); }
+    public static bool operator ==(System.Diagnostics.SymbolStore.SymbolToken a, System.Diagnostics.SymbolStore.SymbolToken b) { return default(bool); }
+    public static bool operator !=(System.Diagnostics.SymbolStore.SymbolToken a, System.Diagnostics.SymbolStore.SymbolToken b) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class SymDocumentType {
+    public static readonly System.Guid Text;
+    public SymDocumentType() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class SymLanguageType {
+    public static readonly System.Guid Basic;
+    public static readonly System.Guid C;
+    public static readonly System.Guid Cobol;
+    public static readonly System.Guid CPlusPlus;
+    public static readonly System.Guid CSharp;
+    public static readonly System.Guid ILAssembly;
+    public static readonly System.Guid Java;
+    public static readonly System.Guid JScript;
+    public static readonly System.Guid MCPlusPlus;
+    public static readonly System.Guid Pascal;
+    public static readonly System.Guid SMC;
+    public SymLanguageType() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class SymLanguageVendor {
+    public static readonly System.Guid Microsoft;
+    public SymLanguageVendor() { }
+  }
+
+} // end of System.Diagnostics.SymbolStore

fxdac/fxdac/Data/Contracts/System.Diagnostics.Tools.cs

@@ -0,0 +1,10 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.CodeDom.Compiler {
+  [System.AttributeUsageAttribute((System.AttributeTargets)(32767), Inherited=false, AllowMultiple=false)]
+  public sealed partial class GeneratedCodeAttribute : System.Attribute {
+    public GeneratedCodeAttribute(string tool, string version) { }
+    public string Tool { get { return default(string); } }
+    public string Version { get { return default(string); } }
+  }
+
+} // end of System.CodeDom.Compiler

fxdac/fxdac/Data/Contracts/System.Diagnostics.TraceSource.cs

@@ -0,0 +1,383 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics {
+  [System.Diagnostics.SwitchLevelAttribute(typeof(bool))]
+  public partial class BooleanSwitch : System.Diagnostics.Switch {
+    public BooleanSwitch(string displayName, string description) : base (default(string), default(string)) { }
+    public BooleanSwitch(string displayName, string description, string defaultSwitchValue) : base (default(string), default(string)) { }
+    public bool Enabled { get { return default(bool); } set { } }
+    protected override void OnValueChanged() { }
+  }
+
+  public partial class CorrelationManager {
+    internal CorrelationManager() { }
+    public System.Guid ActivityId { get { return default(System.Guid); } set { } }
+    public System.Collections.Stack LogicalOperationStack { get { return default(System.Collections.Stack); } }
+    public void StartLogicalOperation() { }
+    public void StartLogicalOperation(object operationId) { }
+    public void StopLogicalOperation() { }
+  }
+
+  public static partial class Debug {
+    public static bool AutoFlush { get { return default(bool); } set { } }
+    public static int IndentLevel { get { return default(int); } set { } }
+    public static int IndentSize { get { return default(int); } set { } }
+    public static System.Diagnostics.TraceListenerCollection Listeners { get { return default(System.Diagnostics.TraceListenerCollection); } }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Assert(bool condition) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Assert(bool condition, string message) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Assert(bool condition, string message, string detailMessage) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Assert(bool condition, string message, string detailMessageFormat, params object[] args) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Close() { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Fail(string message) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Fail(string message, string detailMessage) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Flush() { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Indent() { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Print(string message) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Print(string format, params object[] args) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Unindent() { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Write(object value) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Write(object value, string category) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Write(string message) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void Write(string message, string category) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteIf(bool condition, object value) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteIf(bool condition, object value, string category) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteIf(bool condition, string message) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteIf(bool condition, string message, string category) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLine(object value) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLine(object value, string category) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLine(string message) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLine(string format, params object[] args) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLine(string message, string category) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLineIf(bool condition, object value) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLineIf(bool condition, object value, string category) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLineIf(bool condition, string message) { }
+    [System.Diagnostics.ConditionalAttribute("DEBUG")]
+    public static void WriteLineIf(bool condition, string message, string category) { }
+  }
+
+  public partial class DefaultTraceListener : System.Diagnostics.TraceListener {
+    public DefaultTraceListener() { }
+    public bool AssertUiEnabled { get { return default(bool); } set { } }
+    public string LogFileName { get { return default(string); } set { } }
+    public override void Fail(string message) { }
+    public override void Fail(string message, string detailMessage) { }
+    public override void Write(string message) { }
+    public override void WriteLine(string message) { }
+  }
+
+  [System.FlagsAttribute]
+  public enum SourceLevels {
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(2))]
+    ActivityTracing = 65280,
+    All = -1,
+    Critical = 1,
+    Error = 3,
+    Information = 15,
+    Off = 0,
+    Verbose = 31,
+    Warning = 7,
+  }
+
+  public partial class SourceSwitch : System.Diagnostics.Switch {
+    public SourceSwitch(string name) : base (default(string), default(string)) { }
+    public SourceSwitch(string displayName, string defaultSwitchValue) : base (default(string), default(string)) { }
+    public System.Diagnostics.SourceLevels Level { get { return default(System.Diagnostics.SourceLevels); } set { } }
+    protected override void OnValueChanged() { }
+    public bool ShouldTrace(System.Diagnostics.TraceEventType eventType) { return default(bool); }
+  }
+
+  public abstract partial class Switch {
+    protected Switch(string displayName, string description) { }
+    protected Switch(string displayName, string description, string defaultSwitchValue) { }
+    public System.Collections.Specialized.StringDictionary Attributes { get { return default(System.Collections.Specialized.StringDictionary); } }
+    public string Description { get { return default(string); } }
+    public string DisplayName { get { return default(string); } }
+    protected int SwitchSetting { get { return default(int); } set { } }
+    protected string Value { get { return default(string); } set { } }
+    protected internal virtual string[] GetSupportedAttributes() { return default(string[]); }
+    protected virtual void OnSwitchSettingChanged() { }
+    protected virtual void OnValueChanged() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(741))]
+  public sealed partial class SwitchAttribute : System.Attribute {
+    public SwitchAttribute(string switchName, System.Type switchType) { }
+    public string SwitchDescription { get { return default(string); } set { } }
+    public string SwitchName { get { return default(string); } set { } }
+    public System.Type SwitchType { get { return default(System.Type); } set { } }
+    public static System.Diagnostics.SwitchAttribute[] GetAll(System.Reflection.Assembly assembly) { return default(System.Diagnostics.SwitchAttribute[]); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(4))]
+  public sealed partial class SwitchLevelAttribute : System.Attribute {
+    public SwitchLevelAttribute(System.Type switchLevelType) { }
+    public System.Type SwitchLevelType { get { return default(System.Type); } set { } }
+  }
+
+  public sealed partial class Trace {
+    internal Trace() { }
+    public static bool AutoFlush { get { return default(bool); } set { } }
+    public static System.Diagnostics.CorrelationManager CorrelationManager { get { return default(System.Diagnostics.CorrelationManager); } }
+    public static int IndentLevel { get { return default(int); } set { } }
+    public static int IndentSize { get { return default(int); } set { } }
+    public static System.Diagnostics.TraceListenerCollection Listeners { get { return default(System.Diagnostics.TraceListenerCollection); } }
+    public static bool UseGlobalLock { get { return default(bool); } set { } }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Assert(bool condition) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Assert(bool condition, string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Assert(bool condition, string message, string detailMessage) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Close() { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Fail(string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Fail(string message, string detailMessage) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Flush() { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Indent() { }
+    public static void Refresh() { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void TraceError(string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void TraceError(string format, params object[] args) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void TraceInformation(string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void TraceInformation(string format, params object[] args) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void TraceWarning(string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void TraceWarning(string format, params object[] args) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Unindent() { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Write(object value) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Write(object value, string category) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Write(string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void Write(string message, string category) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteIf(bool condition, object value) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteIf(bool condition, object value, string category) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteIf(bool condition, string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteIf(bool condition, string message, string category) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteLine(object value) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteLine(object value, string category) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteLine(string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteLine(string message, string category) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteLineIf(bool condition, object value) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteLineIf(bool condition, object value, string category) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteLineIf(bool condition, string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public static void WriteLineIf(bool condition, string message, string category) { }
+  }
+
+  public partial class TraceEventCache {
+    public TraceEventCache() { }
+    public string Callstack { get { return default(string); } }
+    public System.DateTime DateTime { get { return default(System.DateTime); } }
+    public System.Collections.Stack LogicalOperationStack { get { return default(System.Collections.Stack); } }
+    public int ProcessId { get { return default(int); } }
+    public string ThreadId { get { return default(string); } }
+    public long Timestamp { get { return default(long); } }
+  }
+
+  public enum TraceEventType {
+    Critical = 1,
+    Error = 2,
+    Information = 8,
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(2))]
+    Resume = 2048,
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(2))]
+    Start = 256,
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(2))]
+    Stop = 512,
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(2))]
+    Suspend = 1024,
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(2))]
+    Transfer = 4096,
+    Verbose = 16,
+    Warning = 4,
+  }
+
+  public abstract partial class TraceFilter {
+    protected TraceFilter() { }
+    public abstract bool ShouldTrace(System.Diagnostics.TraceEventCache cache, string source, System.Diagnostics.TraceEventType eventType, int id, string formatOrMessage, object[] args, object data1, object[] data);
+  }
+
+  public enum TraceLevel {
+    Error = 1,
+    Info = 3,
+    Off = 0,
+    Verbose = 4,
+    Warning = 2,
+  }
+
+  public abstract partial class TraceListener :System.IDisposable {
+    protected TraceListener() { }
+    protected TraceListener(string name) { }
+    public System.Collections.Specialized.StringDictionary Attributes { get { return default(System.Collections.Specialized.StringDictionary); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Diagnostics.TraceFilter Filter { get { return default(System.Diagnostics.TraceFilter); } set { } }
+    public int IndentLevel { get { return default(int); } set { } }
+    public int IndentSize { get { return default(int); } set { } }
+    public virtual bool IsThreadSafe { get { return default(bool); } }
+    public virtual string Name { get { return default(string); } set { } }
+    protected bool NeedIndent { get { return default(bool); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Diagnostics.TraceOptions TraceOutputOptions { get { return default(System.Diagnostics.TraceOptions); } set { } }
+    public virtual void Close() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public virtual void Fail(string message) { }
+    public virtual void Fail(string message, string detailMessage) { }
+    public virtual void Flush() { }
+    protected internal virtual string[] GetSupportedAttributes() { return default(string[]); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual void TraceData(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, object data) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual void TraceData(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, params object[] data) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual void TraceEvent(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual void TraceEvent(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, string message) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual void TraceEvent(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, string format, params object[] args) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual void TraceTransfer(System.Diagnostics.TraceEventCache eventCache, string source, int id, string message, System.Guid relatedActivityId) { }
+    public virtual void Write(object o) { }
+    public virtual void Write(object o, string category) { }
+    public abstract void Write(string message);
+    public virtual void Write(string message, string category) { }
+    protected virtual void WriteIndent() { }
+    public virtual void WriteLine(object o) { }
+    public virtual void WriteLine(object o, string category) { }
+    public abstract void WriteLine(string message);
+    public virtual void WriteLine(string message, string category) { }
+  }
+
+  public partial class TraceListenerCollection : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList {
+    internal TraceListenerCollection() { }
+    public int Count { get { return default(int); } }
+    public System.Diagnostics.TraceListener this[int i] { get { return default(System.Diagnostics.TraceListener); } set { } }
+    public System.Diagnostics.TraceListener this[string name] { get { return default(System.Diagnostics.TraceListener); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    bool System.Collections.IList.IsFixedSize { get { return default(bool); } }
+    bool System.Collections.IList.IsReadOnly { get { return default(bool); } }
+    object System.Collections.IList.this[int index] { get { return default(object); } set { } }
+    public int Add(System.Diagnostics.TraceListener listener) { return default(int); }
+    public void AddRange(System.Diagnostics.TraceListener[] value) { }
+    public void AddRange(System.Diagnostics.TraceListenerCollection value) { }
+    public void Clear() { }
+    public bool Contains(System.Diagnostics.TraceListener listener) { return default(bool); }
+    public void CopyTo(System.Diagnostics.TraceListener[] listeners, int index) { }
+    public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public int IndexOf(System.Diagnostics.TraceListener listener) { return default(int); }
+    public void Insert(int index, System.Diagnostics.TraceListener listener) { }
+    public void Remove(System.Diagnostics.TraceListener listener) { }
+    public void Remove(string name) { }
+    public void RemoveAt(int index) { }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    int System.Collections.IList.Add(object value) { return default(int); }
+    bool System.Collections.IList.Contains(object value) { return default(bool); }
+    int System.Collections.IList.IndexOf(object value) { return default(int); }
+    void System.Collections.IList.Insert(int index, object value) { }
+    void System.Collections.IList.Remove(object value) { }
+  }
+
+  [System.FlagsAttribute]
+  public enum TraceOptions {
+    Callstack = 32,
+    DateTime = 2,
+    LogicalOperationStack = 1,
+    None = 0,
+    ProcessId = 8,
+    ThreadId = 16,
+    Timestamp = 4,
+  }
+
+  public partial class TraceSource {
+    public TraceSource(string name) { }
+    public TraceSource(string name, System.Diagnostics.SourceLevels defaultLevel) { }
+    public System.Collections.Specialized.StringDictionary Attributes { get { return default(System.Collections.Specialized.StringDictionary); } }
+    public System.Diagnostics.TraceListenerCollection Listeners { get { return default(System.Diagnostics.TraceListenerCollection); } }
+    public string Name { get { return default(string); } }
+    public System.Diagnostics.SourceSwitch Switch { get { return default(System.Diagnostics.SourceSwitch); } set { } }
+    public void Close() { }
+    public void Flush() { }
+    protected internal virtual string[] GetSupportedAttributes() { return default(string[]); }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public void TraceData(System.Diagnostics.TraceEventType eventType, int id, object data) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public void TraceData(System.Diagnostics.TraceEventType eventType, int id, params object[] data) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public void TraceEvent(System.Diagnostics.TraceEventType eventType, int id) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public void TraceEvent(System.Diagnostics.TraceEventType eventType, int id, string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public void TraceEvent(System.Diagnostics.TraceEventType eventType, int id, string format, params object[] args) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public void TraceInformation(string message) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public void TraceInformation(string format, params object[] args) { }
+    [System.Diagnostics.ConditionalAttribute("TRACE")]
+    public void TraceTransfer(int id, string message, System.Guid relatedActivityId) { }
+  }
+
+  [System.Diagnostics.SwitchLevelAttribute(typeof(System.Diagnostics.TraceLevel))]
+  public partial class TraceSwitch : System.Diagnostics.Switch {
+    public TraceSwitch(string displayName, string description) : base (default(string), default(string)) { }
+    public TraceSwitch(string displayName, string description, string defaultSwitchValue) : base (default(string), default(string)) { }
+    public System.Diagnostics.TraceLevel Level { get { return default(System.Diagnostics.TraceLevel); } set { } }
+    public bool TraceError { get { return default(bool); } }
+    public bool TraceInfo { get { return default(bool); } }
+    public bool TraceVerbose { get { return default(bool); } }
+    public bool TraceWarning { get { return default(bool); } }
+    protected override void OnSwitchSettingChanged() { }
+    protected override void OnValueChanged() { }
+  }
+
+} // end of System.Diagnostics

fxdac/fxdac/Data/Contracts/System.Diagnostics.Tracing.cs

@@ -0,0 +1,72 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics.Tracing {
+  [System.AttributeUsageAttribute((System.AttributeTargets)(64))]
+  public sealed partial class EventAttribute : System.Attribute {
+    public EventAttribute(int eventId) { }
+    public int EventId { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(int); } }
+  }
+
+  public enum EventCommand {
+    Disable = -3,
+    Enable = -2,
+    SendManifest = -1,
+    Update = 0,
+  }
+
+  public partial class EventCommandEventArgs : System.EventArgs {
+    internal EventCommandEventArgs() { }
+    public System.Collections.Generic.IDictionary<string, string> Arguments { get { return default(System.Collections.Generic.IDictionary<string, string>); } }
+    public System.Diagnostics.Tracing.EventCommand Command { get { return default(System.Diagnostics.Tracing.EventCommand); } }
+    public bool DisableEvent(int eventId) { return default(bool); }
+    public bool EnableEvent(int eventId) { return default(bool); }
+  }
+
+  [System.FlagsAttribute]
+  public enum EventKeywords : long {
+    AuditFailure = (long)4503599627370496,
+    AuditSuccess = (long)9007199254740992,
+    CorrelationHint = (long)4503599627370496,
+    EventLogClassic = (long)36028797018963968,
+    None = (long)0,
+    Sqm = (long)2251799813685248,
+    WdiContext = (long)562949953421312,
+    WdiDiagnostic = (long)1125899906842624,
+  }
+
+  public enum EventLevel {
+    Critical = 1,
+    Error = 2,
+    Informational = 4,
+    LogAlways = 0,
+    Verbose = 5,
+    Warning = 3,
+  }
+
+  public partial class EventSource : System.IDisposable {
+    protected EventSource() { }
+    protected EventSource(bool throwOnEventWriteErrors) { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public bool IsEnabled() { return default(bool); }
+    public bool IsEnabled(System.Diagnostics.Tracing.EventLevel level, System.Diagnostics.Tracing.EventKeywords keywords) { return default(bool); }
+    protected virtual void OnEventCommand(System.Diagnostics.Tracing.EventCommandEventArgs command) { }
+    protected void WriteEvent(int eventId, int arg1, int arg2, int arg3) { }
+    protected void WriteEvent(int eventId, string arg1) { }
+    protected void WriteEvent(int eventId, string arg1, int arg2) { }
+    protected void WriteEvent(int eventId, string arg1, int arg2, int arg3) { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(4))]
+  public sealed partial class EventSourceAttribute : System.Attribute {
+    public EventSourceAttribute() { }
+    public string Guid { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(string); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public string LocalizationResources { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(string); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(string); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(64))]
+  public sealed partial class NonEventAttribute : System.Attribute {
+    public NonEventAttribute() { }
+  }
+
+} // end of System.Diagnostics.Tracing

fxdac/fxdac/Data/Contracts/System.Dynamic.cs

@@ -0,0 +1 @@
+[assembly:System.CLSCompliant(true)]

fxdac/fxdac/Data/Contracts/System.Globalization.Calendars.cs

@@ -0,0 +1,399 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Globalization {
+  public partial class ChineseLunisolarCalendar : System.Globalization.EastAsianLunisolarCalendar {
+    public const int ChineseEra = 1;
+    public ChineseLunisolarCalendar() { }
+    protected override int DaysInYearBeforeMinSupportedYear { get { return default(int); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int[] Eras { get { return default(int[]); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetEra(System.DateTime time) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class EastAsianLunisolarCalendar : System.Globalization.Calendar {
+    internal EastAsianLunisolarCalendar() { }
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public int GetCelestialStem(int sexagenaryYear) { return default(int); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    public virtual int GetSexagenaryYear(System.DateTime time) { return default(int); }
+    public int GetTerrestrialBranch(int sexagenaryYear) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class GregorianCalendar : System.Globalization.Calendar {
+    public const int ADEra = 1;
+    public GregorianCalendar() { }
+    public GregorianCalendar(System.Globalization.GregorianCalendarTypes type) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public virtual System.Globalization.GregorianCalendarTypes CalendarType { get { return default(System.Globalization.GregorianCalendarTypes); } set { } }
+    public override int[] Eras { get { return default(int[]); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum GregorianCalendarTypes {
+    Arabic = 10,
+    Localized = 1,
+    MiddleEastFrench = 9,
+    TransliteratedEnglish = 11,
+    TransliteratedFrench = 12,
+    USEnglish = 2,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HebrewCalendar : System.Globalization.Calendar {
+    public static readonly int HebrewEra;
+    public HebrewCalendar() { }
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public override int[] Eras { get { return default(int[]); } }
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HijriCalendar : System.Globalization.Calendar {
+    public static readonly int HijriEra;
+    public HijriCalendar() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    protected override int DaysInYearBeforeMinSupportedYear { get { return default(int); } }
+    public override int[] Eras { get { return default(int[]); } }
+    public int HijriAdjustment { [System.Security.SecuritySafeCriticalAttribute]get { return default(int); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class JapaneseCalendar : System.Globalization.Calendar {
+    public JapaneseCalendar() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public override int[] Eras { get { return default(int[]); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetWeekOfYear(System.DateTime time, System.Globalization.CalendarWeekRule rule, System.DayOfWeek firstDayOfWeek) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  public partial class JapaneseLunisolarCalendar : System.Globalization.EastAsianLunisolarCalendar {
+    public const int JapaneseEra = 1;
+    public JapaneseLunisolarCalendar() { }
+    protected override int DaysInYearBeforeMinSupportedYear { get { return default(int); } }
+    public override int[] Eras { get { return default(int[]); } }
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int GetEra(System.DateTime time) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class JulianCalendar : System.Globalization.Calendar {
+    public static readonly int JulianEra;
+    public JulianCalendar() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public override int[] Eras { get { return default(int[]); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class KoreanCalendar : System.Globalization.Calendar {
+    public const int KoreanEra = 1;
+    public KoreanCalendar() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public override int[] Eras { get { return default(int[]); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetWeekOfYear(System.DateTime time, System.Globalization.CalendarWeekRule rule, System.DayOfWeek firstDayOfWeek) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  public partial class KoreanLunisolarCalendar : System.Globalization.EastAsianLunisolarCalendar {
+    public const int GregorianEra = 1;
+    public KoreanLunisolarCalendar() { }
+    protected override int DaysInYearBeforeMinSupportedYear { get { return default(int); } }
+    public override int[] Eras { get { return default(int[]); } }
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int GetEra(System.DateTime time) { return default(int); }
+  }
+
+  public partial class PersianCalendar : System.Globalization.Calendar {
+    public static readonly int PersianEra;
+    public PersianCalendar() { }
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public override int[] Eras { get { return default(int[]); } }
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class TaiwanCalendar : System.Globalization.Calendar {
+    public TaiwanCalendar() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public override int[] Eras { get { return default(int[]); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetWeekOfYear(System.DateTime time, System.Globalization.CalendarWeekRule rule, System.DayOfWeek firstDayOfWeek) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  public partial class TaiwanLunisolarCalendar : System.Globalization.EastAsianLunisolarCalendar {
+    public TaiwanLunisolarCalendar() { }
+    protected override int DaysInYearBeforeMinSupportedYear { get { return default(int); } }
+    public override int[] Eras { get { return default(int[]); } }
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int GetEra(System.DateTime time) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ThaiBuddhistCalendar : System.Globalization.Calendar {
+    public const int ThaiBuddhistEra = 1;
+    public ThaiBuddhistCalendar() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    public override int[] Eras { get { return default(int[]); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetWeekOfYear(System.DateTime time, System.Globalization.CalendarWeekRule rule, System.DayOfWeek firstDayOfWeek) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+  public partial class UmAlQuraCalendar : System.Globalization.Calendar {
+    public const int UmAlQuraEra = 1;
+    public UmAlQuraCalendar() { }
+    public override System.Globalization.CalendarAlgorithmType AlgorithmType { get { return default(System.Globalization.CalendarAlgorithmType); } }
+    protected override int DaysInYearBeforeMinSupportedYear { get { return default(int); } }
+    public override int[] Eras { get { return default(int[]); } }
+    public override System.DateTime MaxSupportedDateTime { get { return default(System.DateTime); } }
+    public override System.DateTime MinSupportedDateTime { get { return default(System.DateTime); } }
+    public override int TwoDigitYearMax { get { return default(int); } set { } }
+    public override System.DateTime AddMonths(System.DateTime time, int months) { return default(System.DateTime); }
+    public override System.DateTime AddYears(System.DateTime time, int years) { return default(System.DateTime); }
+    public override int GetDayOfMonth(System.DateTime time) { return default(int); }
+    public override System.DayOfWeek GetDayOfWeek(System.DateTime time) { return default(System.DayOfWeek); }
+    public override int GetDayOfYear(System.DateTime time) { return default(int); }
+    public override int GetDaysInMonth(int year, int month, int era) { return default(int); }
+    public override int GetDaysInYear(int year, int era) { return default(int); }
+    public override int GetEra(System.DateTime time) { return default(int); }
+    public override int GetLeapMonth(int year, int era) { return default(int); }
+    public override int GetMonth(System.DateTime time) { return default(int); }
+    public override int GetMonthsInYear(int year, int era) { return default(int); }
+    public override int GetYear(System.DateTime time) { return default(int); }
+    public override bool IsLeapDay(int year, int month, int day, int era) { return default(bool); }
+    public override bool IsLeapMonth(int year, int month, int era) { return default(bool); }
+    public override bool IsLeapYear(int year, int era) { return default(bool); }
+    public override System.DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era) { return default(System.DateTime); }
+    public override int ToFourDigitYear(int year) { return default(int); }
+  }
+
+} // end of System.Globalization

fxdac/fxdac/Data/Contracts/System.Globalization.Extensions.cs

@@ -0,0 +1,17 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Globalization {
+  public sealed partial class IdnMapping {
+    public IdnMapping() { }
+    public bool AllowUnassigned { get { return default(bool); } set { } }
+    public bool UseStd3AsciiRules { get { return default(bool); } set { } }
+    public override bool Equals(object obj) { return default(bool); }
+    public string GetAscii(string unicode) { return default(string); }
+    public string GetAscii(string unicode, int index) { return default(string); }
+    public string GetAscii(string unicode, int index, int count) { return default(string); }
+    public override int GetHashCode() { return default(int); }
+    public string GetUnicode(string ascii) { return default(string); }
+    public string GetUnicode(string ascii, int index) { return default(string); }
+    public string GetUnicode(string ascii, int index, int count) { return default(string); }
+  }
+
+} // end of System.Globalization

fxdac/fxdac/Data/Contracts/System.Globalization.cs

@@ -0,0 +1,113 @@
+[assembly:System.CLSCompliant(true)]
+namespace System {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class TimeZone {
+    protected TimeZone() { }
+    public static System.TimeZone CurrentTimeZone { get { return default(System.TimeZone); } }
+    public abstract string DaylightName { get; }
+    public abstract string StandardName { get; }
+    public abstract System.Globalization.DaylightTime GetDaylightChanges(int year);
+    public abstract System.TimeSpan GetUtcOffset(System.DateTime time);
+    public virtual bool IsDaylightSavingTime(System.DateTime time) { return default(bool); }
+    public static bool IsDaylightSavingTime(System.DateTime time, System.Globalization.DaylightTime daylightTimes) { return default(bool); }
+    public virtual System.DateTime ToLocalTime(System.DateTime time) { return default(System.DateTime); }
+    public virtual System.DateTime ToUniversalTime(System.DateTime time) { return default(System.DateTime); }
+  }
+
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")]
+  public partial class TimeZoneNotFoundException : System.Exception {
+    public TimeZoneNotFoundException() { }
+    protected TimeZoneNotFoundException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public TimeZoneNotFoundException(string message) { }
+    public TimeZoneNotFoundException(string message, System.Exception innerException) { }
+  }
+
+} // end of System
+namespace System.Globalization {
+  public static partial class CharUnicodeInfo {
+    public static int GetDecimalDigitValue(char ch) { return default(int); }
+    public static int GetDecimalDigitValue(string s, int index) { return default(int); }
+    public static int GetDigitValue(char ch) { return default(int); }
+    public static int GetDigitValue(string s, int index) { return default(int); }
+    public static double GetNumericValue(char ch) { return default(double); }
+    public static double GetNumericValue(string s, int index) { return default(double); }
+    public static System.Globalization.UnicodeCategory GetUnicodeCategory(char ch) { return default(System.Globalization.UnicodeCategory); }
+    public static System.Globalization.UnicodeCategory GetUnicodeCategory(string s, int index) { return default(System.Globalization.UnicodeCategory); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class DaylightTime {
+    public DaylightTime(System.DateTime start, System.DateTime end, System.TimeSpan delta) { }
+    public System.TimeSpan Delta { get { return default(System.TimeSpan); } }
+    public System.DateTime End { get { return default(System.DateTime); } }
+    public System.DateTime Start { get { return default(System.DateTime); } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class RegionInfo {
+    public RegionInfo(int culture) { }
+    public RegionInfo(string name) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual string CurrencyEnglishName { get { return default(string); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual string CurrencyNativeName { get { return default(string); } }
+    public virtual string CurrencySymbol { get { return default(string); } }
+    public static System.Globalization.RegionInfo CurrentRegion { get { return default(System.Globalization.RegionInfo); } }
+    public virtual string DisplayName { get { return default(string); } }
+    public virtual string EnglishName { get { return default(string); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual int GeoId { get { return default(int); } }
+    public virtual bool IsMetric { get { return default(bool); } }
+    public virtual string ISOCurrencySymbol { get { return default(string); } }
+    public virtual string Name { get { return default(string); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual string NativeName { get { return default(string); } }
+    public virtual string ThreeLetterISORegionName { get { return default(string); } }
+    public virtual string ThreeLetterWindowsRegionName { get { return default(string); } }
+    public virtual string TwoLetterISORegionName { get { return default(string); } }
+    public override bool Equals(object value) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  public sealed partial class SortVersion : System.IEquatable<System.Globalization.SortVersion> {
+    public SortVersion(int fullVersion, System.Guid sortId) { }
+    public int FullVersion { get { return default(int); } }
+    public System.Guid SortId { get { return default(System.Guid); } }
+    public bool Equals(System.Globalization.SortVersion other) { return default(bool); }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public static bool operator ==(System.Globalization.SortVersion left, System.Globalization.SortVersion right) { return default(bool); }
+    public static bool operator !=(System.Globalization.SortVersion left, System.Globalization.SortVersion right) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class StringInfo {
+    public StringInfo() { }
+    public StringInfo(string value) { }
+    public int LengthInTextElements { get { return default(int); } }
+    public string String { get { return default(string); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override bool Equals(object value) { return default(bool); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetHashCode() { return default(int); }
+    public static string GetNextTextElement(string str) { return default(string); }
+    public static string GetNextTextElement(string str, int index) { return default(string); }
+    public static System.Globalization.TextElementEnumerator GetTextElementEnumerator(string str) { return default(System.Globalization.TextElementEnumerator); }
+    public static System.Globalization.TextElementEnumerator GetTextElementEnumerator(string str, int index) { return default(System.Globalization.TextElementEnumerator); }
+    public static int[] ParseCombiningCharacters(string str) { return default(int[]); }
+    public string SubstringByTextElements(int startingTextElement) { return default(string); }
+    public string SubstringByTextElements(int startingTextElement, int lengthInTextElements) { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class TextElementEnumerator : System.Collections.IEnumerator {
+    internal TextElementEnumerator() { }
+    public object Current { get { return default(object); } }
+    public int ElementIndex { get { return default(int); } }
+    public string GetTextElement() { return default(string); }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+} // end of System.Globalization

fxdac/fxdac/Data/Contracts/System.IO.Compression.cs

@@ -0,0 +1,60 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.IO.Compression {
+  public enum CompressionLevel {
+    Fastest = 1,
+    NoCompression = 2,
+    Optimal = 0,
+  }
+
+  public enum CompressionMode {
+    Compress = 1,
+    Decompress = 0,
+  }
+
+  public partial class DeflateStream : System.IO.Stream {
+    public DeflateStream(System.IO.Stream stream, System.IO.Compression.CompressionLevel compressionLevel) { }
+    public DeflateStream(System.IO.Stream stream, System.IO.Compression.CompressionLevel compressionLevel, bool leaveOpen) { }
+    public DeflateStream(System.IO.Stream compressedStream, System.IO.Compression.CompressionMode mode) { }
+    public DeflateStream(System.IO.Stream compressedStream, System.IO.Compression.CompressionMode mode, bool leaveOpen) { }
+    public System.IO.Stream BaseStream { get { return default(System.IO.Stream); } }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    public override long Length { get { return default(long); } }
+    public override long Position { get { return default(long); } set { } }
+    public override System.IAsyncResult BeginRead(byte[] buffer, int offset, int count, System.AsyncCallback cback, object state) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginWrite(byte[] buffer, int offset, int count, System.AsyncCallback cback, object state) { return default(System.IAsyncResult); }
+    protected override void Dispose(bool disposing) { }
+    public override int EndRead(System.IAsyncResult async_result) { return default(int); }
+    public override void EndWrite(System.IAsyncResult async_result) { }
+    public override void Flush() { }
+    public override int Read(byte[] dest, int dest_offset, int count) { return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin origin) { return default(long); }
+    public override void SetLength(long value) { }
+    public override void Write(byte[] src, int src_offset, int count) { }
+  }
+
+  public partial class GZipStream : System.IO.Stream {
+    public GZipStream(System.IO.Stream stream, System.IO.Compression.CompressionLevel compressionLevel) { }
+    public GZipStream(System.IO.Stream stream, System.IO.Compression.CompressionLevel compressionLevel, bool leaveOpen) { }
+    public GZipStream(System.IO.Stream stream, System.IO.Compression.CompressionMode mode) { }
+    public GZipStream(System.IO.Stream stream, System.IO.Compression.CompressionMode mode, bool leaveOpen) { }
+    public System.IO.Stream BaseStream { get { return default(System.IO.Stream); } }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    public override long Length { get { return default(long); } }
+    public override long Position { get { return default(long); } set { } }
+    public override System.IAsyncResult BeginRead(byte[] buffer, int offset, int count, System.AsyncCallback cback, object state) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginWrite(byte[] buffer, int offset, int count, System.AsyncCallback cback, object state) { return default(System.IAsyncResult); }
+    protected override void Dispose(bool disposing) { }
+    public override int EndRead(System.IAsyncResult async_result) { return default(int); }
+    public override void EndWrite(System.IAsyncResult async_result) { }
+    public override void Flush() { }
+    public override int Read(byte[] dest, int dest_offset, int count) { return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin origin) { return default(long); }
+    public override void SetLength(long value) { }
+    public override void Write(byte[] src, int src_offset, int count) { }
+  }
+
+} // end of System.IO.Compression

fxdac/fxdac/Data/Contracts/System.IO.FileSystem.AccessControl.cs

@@ -0,0 +1,98 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.AccessControl {
+  public abstract partial class DirectoryObjectSecurity : System.Security.AccessControl.ObjectSecurity {
+    protected DirectoryObjectSecurity() : base (default(bool), default(bool)) { }
+    protected DirectoryObjectSecurity(System.Security.AccessControl.CommonSecurityDescriptor securityDescriptor) : base (default(bool), default(bool)) { }
+    public virtual System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type, System.Guid objectType, System.Guid inheritedObjectType) { return default(System.Security.AccessControl.AccessRule); }
+    protected void AddAccessRule(System.Security.AccessControl.ObjectAccessRule rule) { }
+    protected void AddAuditRule(System.Security.AccessControl.ObjectAuditRule rule) { }
+    public virtual System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags, System.Guid objectType, System.Guid inheritedObjectType) { return default(System.Security.AccessControl.AuditRule); }
+    public System.Security.AccessControl.AuthorizationRuleCollection GetAccessRules(bool includeExplicit, bool includeInherited, System.Type targetType) { return default(System.Security.AccessControl.AuthorizationRuleCollection); }
+    public System.Security.AccessControl.AuthorizationRuleCollection GetAuditRules(bool includeExplicit, bool includeInherited, System.Type targetType) { return default(System.Security.AccessControl.AuthorizationRuleCollection); }
+    protected override bool ModifyAccess(System.Security.AccessControl.AccessControlModification modification, System.Security.AccessControl.AccessRule rule, out bool modified) { modified = default(bool); return default(bool); }
+    protected override bool ModifyAudit(System.Security.AccessControl.AccessControlModification modification, System.Security.AccessControl.AuditRule rule, out bool modified) { modified = default(bool); return default(bool); }
+    protected bool RemoveAccessRule(System.Security.AccessControl.ObjectAccessRule rule) { return default(bool); }
+    protected void RemoveAccessRuleAll(System.Security.AccessControl.ObjectAccessRule rule) { }
+    protected void RemoveAccessRuleSpecific(System.Security.AccessControl.ObjectAccessRule rule) { }
+    protected bool RemoveAuditRule(System.Security.AccessControl.ObjectAuditRule rule) { return default(bool); }
+    protected void RemoveAuditRuleAll(System.Security.AccessControl.ObjectAuditRule rule) { }
+    protected void RemoveAuditRuleSpecific(System.Security.AccessControl.ObjectAuditRule rule) { }
+    protected void ResetAccessRule(System.Security.AccessControl.ObjectAccessRule rule) { }
+    protected void SetAccessRule(System.Security.AccessControl.ObjectAccessRule rule) { }
+    protected void SetAuditRule(System.Security.AccessControl.ObjectAuditRule rule) { }
+  }
+
+  public sealed partial class DirectorySecurity : System.Security.AccessControl.FileSystemSecurity {
+    public DirectorySecurity() { }
+    public DirectorySecurity(string name, System.Security.AccessControl.AccessControlSections includeSections) { }
+  }
+
+  public sealed partial class FileSecurity : System.Security.AccessControl.FileSystemSecurity {
+    public FileSecurity() { }
+    public FileSecurity(string fileName, System.Security.AccessControl.AccessControlSections includeSections) { }
+  }
+
+  public sealed partial class FileSystemAccessRule : System.Security.AccessControl.AccessRule {
+    public FileSystemAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.FileSystemRights fileSystemRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public FileSystemAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.FileSystemRights fileSystemRights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public FileSystemAccessRule(string identity, System.Security.AccessControl.FileSystemRights fileSystemRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public FileSystemAccessRule(string identity, System.Security.AccessControl.FileSystemRights fileSystemRights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public System.Security.AccessControl.FileSystemRights FileSystemRights { get { return default(System.Security.AccessControl.FileSystemRights); } }
+  }
+
+  public sealed partial class FileSystemAuditRule : System.Security.AccessControl.AuditRule {
+    public FileSystemAuditRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.FileSystemRights fileSystemRights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public FileSystemAuditRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.FileSystemRights fileSystemRights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public FileSystemAuditRule(string identity, System.Security.AccessControl.FileSystemRights fileSystemRights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public FileSystemAuditRule(string identity, System.Security.AccessControl.FileSystemRights fileSystemRights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public System.Security.AccessControl.FileSystemRights FileSystemRights { get { return default(System.Security.AccessControl.FileSystemRights); } }
+  }
+
+  [System.FlagsAttribute]
+  public enum FileSystemRights {
+    AppendData = 4,
+    ChangePermissions = 262144,
+    CreateDirectories = 4,
+    CreateFiles = 2,
+    Delete = 65536,
+    DeleteSubdirectoriesAndFiles = 64,
+    ExecuteFile = 32,
+    FullControl = 2032127,
+    ListDirectory = 1,
+    Modify = 197055,
+    Read = 131209,
+    ReadAndExecute = 131241,
+    ReadAttributes = 128,
+    ReadData = 1,
+    ReadExtendedAttributes = 8,
+    ReadPermissions = 131072,
+    Synchronize = 1048576,
+    TakeOwnership = 524288,
+    Traverse = 32,
+    Write = 278,
+    WriteAttributes = 256,
+    WriteData = 2,
+    WriteExtendedAttributes = 16,
+  }
+
+  public abstract partial class FileSystemSecurity : System.Security.AccessControl.NativeObjectSecurity {
+    internal FileSystemSecurity() : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public override System.Type AccessRightType { get { return default(System.Type); } }
+    public override System.Type AccessRuleType { get { return default(System.Type); } }
+    public override System.Type AuditRuleType { get { return default(System.Type); } }
+    public sealed override System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) { return default(System.Security.AccessControl.AccessRule); }
+    public void AddAccessRule(System.Security.AccessControl.FileSystemAccessRule rule) { }
+    public void AddAuditRule(System.Security.AccessControl.FileSystemAuditRule rule) { }
+    public sealed override System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) { return default(System.Security.AccessControl.AuditRule); }
+    public bool RemoveAccessRule(System.Security.AccessControl.FileSystemAccessRule rule) { return default(bool); }
+    public void RemoveAccessRuleAll(System.Security.AccessControl.FileSystemAccessRule rule) { }
+    public void RemoveAccessRuleSpecific(System.Security.AccessControl.FileSystemAccessRule rule) { }
+    public bool RemoveAuditRule(System.Security.AccessControl.FileSystemAuditRule rule) { return default(bool); }
+    public void RemoveAuditRuleAll(System.Security.AccessControl.FileSystemAuditRule rule) { }
+    public void RemoveAuditRuleSpecific(System.Security.AccessControl.FileSystemAuditRule rule) { }
+    public void ResetAccessRule(System.Security.AccessControl.FileSystemAccessRule rule) { }
+    public void SetAccessRule(System.Security.AccessControl.FileSystemAccessRule rule) { }
+    public void SetAuditRule(System.Security.AccessControl.FileSystemAuditRule rule) { }
+  }
+
+} // end of System.Security.AccessControl

fxdac/fxdac/Data/Contracts/System.IO.FileSystem.DriveInfo.cs

@@ -0,0 +1,39 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.IO {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class DriveInfo : System.Runtime.Serialization.ISerializable {
+    public DriveInfo(string driveName) { }
+    public long AvailableFreeSpace { get { return default(long); } }
+    public string DriveFormat { get { return default(string); } }
+    public System.IO.DriveType DriveType { get { return default(System.IO.DriveType); } }
+    public bool IsReady { get { return default(bool); } }
+    public string Name { get { return default(string); } }
+    public System.IO.DirectoryInfo RootDirectory { get { return default(System.IO.DirectoryInfo); } }
+    public long TotalFreeSpace { get { return default(long); } }
+    public long TotalSize { get { return default(long); } }
+    public string VolumeLabel { get { return default(string); } set { } }
+    public static System.IO.DriveInfo[] GetDrives() { return default(System.IO.DriveInfo[]); }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class DriveNotFoundException : System.IO.IOException {
+    public DriveNotFoundException() { }
+    protected DriveNotFoundException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public DriveNotFoundException(string message) { }
+    public DriveNotFoundException(string message, System.Exception innerException) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum DriveType {
+    CDRom = 5,
+    Fixed = 3,
+    Network = 4,
+    NoRootDirectory = 1,
+    Ram = 6,
+    Removable = 2,
+    Unknown = 0,
+  }
+
+} // end of System.IO

fxdac/fxdac/Data/Contracts/System.IO.FileSystem.Primitives.cs

@@ -0,0 +1,24 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.IO {
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum FileAttributes {
+    Archive = 32,
+    Compressed = 2048,
+    Device = 64,
+    Directory = 16,
+    Encrypted = 16384,
+    Hidden = 2,
+    IntegrityStream = 32768,
+    Normal = 128,
+    NoScrubData = 131072,
+    NotContentIndexed = 8192,
+    Offline = 4096,
+    ReadOnly = 1,
+    ReparsePoint = 1024,
+    SparseFile = 512,
+    System = 4,
+    Temporary = 256,
+  }
+
+} // end of System.IO

fxdac/fxdac/Data/Contracts/System.IO.FileSystem.Watcher.cs

@@ -0,0 +1,10 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.IO {
+  public partial class InternalBufferOverflowException : System.SystemException {
+    public InternalBufferOverflowException() { }
+    protected InternalBufferOverflowException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public InternalBufferOverflowException(string message) { }
+    public InternalBufferOverflowException(string message, System.Exception inner) { }
+  }
+
+} // end of System.IO

fxdac/fxdac/Data/Contracts/System.IO.FileSystem.cs

@@ -0,0 +1,223 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.IO {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public static partial class Directory {
+    public static System.IO.DirectoryInfo CreateDirectory(string path) { return default(System.IO.DirectoryInfo); }
+    public static System.IO.DirectoryInfo CreateDirectory(string path, System.Security.AccessControl.DirectorySecurity directorySecurity) { return default(System.IO.DirectoryInfo); }
+    public static void Delete(string path) { }
+    public static void Delete(string path, bool recursive) { }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories(string path) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories(string path, string searchPattern) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories(string path, string searchPattern, System.IO.SearchOption searchOption) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateFiles(string path) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateFiles(string path, string searchPattern) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateFiles(string path, string searchPattern, System.IO.SearchOption searchOption) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateFileSystemEntries(string path) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, System.IO.SearchOption searchOption) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static bool Exists(string path) { return default(bool); }
+    public static System.Security.AccessControl.DirectorySecurity GetAccessControl(string path) { return default(System.Security.AccessControl.DirectorySecurity); }
+    public static System.Security.AccessControl.DirectorySecurity GetAccessControl(string path, System.Security.AccessControl.AccessControlSections includeSections) { return default(System.Security.AccessControl.DirectorySecurity); }
+    public static System.DateTime GetCreationTime(string path) { return default(System.DateTime); }
+    public static System.DateTime GetCreationTimeUtc(string path) { return default(System.DateTime); }
+    public static string GetCurrentDirectory() { return default(string); }
+    public static string[] GetDirectories(string path) { return default(string[]); }
+    public static string[] GetDirectories(string path, string searchPattern) { return default(string[]); }
+    public static string[] GetDirectories(string path, string searchPattern, System.IO.SearchOption searchOption) { return default(string[]); }
+    public static string GetDirectoryRoot(string path) { return default(string); }
+    public static string[] GetFiles(string path) { return default(string[]); }
+    public static string[] GetFiles(string path, string searchPattern) { return default(string[]); }
+    public static string[] GetFiles(string path, string searchPattern, System.IO.SearchOption searchOption) { return default(string[]); }
+    public static string[] GetFileSystemEntries(string path) { return default(string[]); }
+    public static string[] GetFileSystemEntries(string path, string searchPattern) { return default(string[]); }
+    public static string[] GetFileSystemEntries(string path, string searchPattern, System.IO.SearchOption searchOption) { return default(string[]); }
+    public static System.DateTime GetLastAccessTime(string path) { return default(System.DateTime); }
+    public static System.DateTime GetLastAccessTimeUtc(string path) { return default(System.DateTime); }
+    public static System.DateTime GetLastWriteTime(string path) { return default(System.DateTime); }
+    public static System.DateTime GetLastWriteTimeUtc(string path) { return default(System.DateTime); }
+    public static string[] GetLogicalDrives() { return default(string[]); }
+    public static System.IO.DirectoryInfo GetParent(string path) { return default(System.IO.DirectoryInfo); }
+    public static void Move(string sourceDirName, string destDirName) { }
+    public static void SetAccessControl(string path, System.Security.AccessControl.DirectorySecurity directorySecurity) { }
+    public static void SetCreationTime(string path, System.DateTime creationTime) { }
+    public static void SetCreationTimeUtc(string path, System.DateTime creationTimeUtc) { }
+    public static void SetCurrentDirectory(string path) { }
+    public static void SetLastAccessTime(string path, System.DateTime lastAccessTime) { }
+    public static void SetLastAccessTimeUtc(string path, System.DateTime lastAccessTimeUtc) { }
+    public static void SetLastWriteTime(string path, System.DateTime lastWriteTime) { }
+    public static void SetLastWriteTimeUtc(string path, System.DateTime lastWriteTimeUtc) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class DirectoryInfo : System.IO.FileSystemInfo {
+    public DirectoryInfo(string path) { }
+    public override bool Exists { get { return default(bool); } }
+    public override string Name { get { return default(string); } }
+    public System.IO.DirectoryInfo Parent { get { return default(System.IO.DirectoryInfo); } }
+    public System.IO.DirectoryInfo Root { get { return default(System.IO.DirectoryInfo); } }
+    public void Create() { }
+    public void Create(System.Security.AccessControl.DirectorySecurity directorySecurity) { }
+    public System.IO.DirectoryInfo CreateSubdirectory(string path) { return default(System.IO.DirectoryInfo); }
+    public System.IO.DirectoryInfo CreateSubdirectory(string path, System.Security.AccessControl.DirectorySecurity directorySecurity) { return default(System.IO.DirectoryInfo); }
+    public override void Delete() { }
+    public void Delete(bool recursive) { }
+    public System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo> EnumerateDirectories() { return default(System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo>); }
+    public System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo> EnumerateDirectories(string searchPattern) { return default(System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo>); }
+    public System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo> EnumerateDirectories(string searchPattern, System.IO.SearchOption searchOption) { return default(System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo>); }
+    public System.Collections.Generic.IEnumerable<System.IO.FileInfo> EnumerateFiles() { return default(System.Collections.Generic.IEnumerable<System.IO.FileInfo>); }
+    public System.Collections.Generic.IEnumerable<System.IO.FileInfo> EnumerateFiles(string searchPattern) { return default(System.Collections.Generic.IEnumerable<System.IO.FileInfo>); }
+    public System.Collections.Generic.IEnumerable<System.IO.FileInfo> EnumerateFiles(string searchPattern, System.IO.SearchOption searchOption) { return default(System.Collections.Generic.IEnumerable<System.IO.FileInfo>); }
+    public System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo> EnumerateFileSystemInfos() { return default(System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo>); }
+    public System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo> EnumerateFileSystemInfos(string searchPattern) { return default(System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo>); }
+    public System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo> EnumerateFileSystemInfos(string searchPattern, System.IO.SearchOption searchOption) { return default(System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo>); }
+    public System.Security.AccessControl.DirectorySecurity GetAccessControl() { return default(System.Security.AccessControl.DirectorySecurity); }
+    public System.Security.AccessControl.DirectorySecurity GetAccessControl(System.Security.AccessControl.AccessControlSections includeSections) { return default(System.Security.AccessControl.DirectorySecurity); }
+    public System.IO.DirectoryInfo[] GetDirectories() { return default(System.IO.DirectoryInfo[]); }
+    public System.IO.DirectoryInfo[] GetDirectories(string searchPattern) { return default(System.IO.DirectoryInfo[]); }
+    public System.IO.DirectoryInfo[] GetDirectories(string searchPattern, System.IO.SearchOption searchOption) { return default(System.IO.DirectoryInfo[]); }
+    public System.IO.FileInfo[] GetFiles() { return default(System.IO.FileInfo[]); }
+    public System.IO.FileInfo[] GetFiles(string searchPattern) { return default(System.IO.FileInfo[]); }
+    public System.IO.FileInfo[] GetFiles(string searchPattern, System.IO.SearchOption searchOption) { return default(System.IO.FileInfo[]); }
+    public System.IO.FileSystemInfo[] GetFileSystemInfos() { return default(System.IO.FileSystemInfo[]); }
+    public System.IO.FileSystemInfo[] GetFileSystemInfos(string searchPattern) { return default(System.IO.FileSystemInfo[]); }
+    public System.IO.FileSystemInfo[] GetFileSystemInfos(string searchPattern, System.IO.SearchOption searchOption) { return default(System.IO.FileSystemInfo[]); }
+    public void MoveTo(string destDirName) { }
+    public void SetAccessControl(System.Security.AccessControl.DirectorySecurity directorySecurity) { }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public static partial class File {
+    public static void AppendAllLines(string path, System.Collections.Generic.IEnumerable<string> contents) { }
+    public static void AppendAllLines(string path, System.Collections.Generic.IEnumerable<string> contents, System.Text.Encoding encoding) { }
+    public static void AppendAllText(string path, string contents) { }
+    public static void AppendAllText(string path, string contents, System.Text.Encoding encoding) { }
+    public static System.IO.StreamWriter AppendText(string path) { return default(System.IO.StreamWriter); }
+    public static void Copy(string sourceFileName, string destFileName) { }
+    public static void Copy(string sourceFileName, string destFileName, bool overwrite) { }
+    public static System.IO.FileStream Create(string path) { return default(System.IO.FileStream); }
+    public static System.IO.FileStream Create(string path, int bufferSize) { return default(System.IO.FileStream); }
+    public static System.IO.StreamWriter CreateText(string path) { return default(System.IO.StreamWriter); }
+    public static void Decrypt(string path) { }
+    public static void Delete(string path) { }
+    public static void Encrypt(string path) { }
+    public static bool Exists(string path) { return default(bool); }
+    public static System.IO.FileAttributes GetAttributes(string path) { return default(System.IO.FileAttributes); }
+    public static System.DateTime GetCreationTime(string path) { return default(System.DateTime); }
+    public static System.DateTime GetCreationTimeUtc(string path) { return default(System.DateTime); }
+    public static System.DateTime GetLastAccessTime(string path) { return default(System.DateTime); }
+    public static System.DateTime GetLastAccessTimeUtc(string path) { return default(System.DateTime); }
+    public static System.DateTime GetLastWriteTime(string path) { return default(System.DateTime); }
+    public static System.DateTime GetLastWriteTimeUtc(string path) { return default(System.DateTime); }
+    public static void Move(string sourceFileName, string destFileName) { }
+    public static System.IO.FileStream Open(string path, System.IO.FileMode mode) { return default(System.IO.FileStream); }
+    public static System.IO.FileStream Open(string path, System.IO.FileMode mode, System.IO.FileAccess access) { return default(System.IO.FileStream); }
+    public static System.IO.FileStream Open(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share) { return default(System.IO.FileStream); }
+    public static System.IO.FileStream OpenRead(string path) { return default(System.IO.FileStream); }
+    public static System.IO.StreamReader OpenText(string path) { return default(System.IO.StreamReader); }
+    public static System.IO.FileStream OpenWrite(string path) { return default(System.IO.FileStream); }
+    public static byte[] ReadAllBytes(string path) { return default(byte[]); }
+    public static string[] ReadAllLines(string path) { return default(string[]); }
+    public static string[] ReadAllLines(string path, System.Text.Encoding encoding) { return default(string[]); }
+    public static string ReadAllText(string path) { return default(string); }
+    public static string ReadAllText(string path, System.Text.Encoding encoding) { return default(string); }
+    public static System.Collections.Generic.IEnumerable<string> ReadLines(string path) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static System.Collections.Generic.IEnumerable<string> ReadLines(string path, System.Text.Encoding encoding) { return default(System.Collections.Generic.IEnumerable<string>); }
+    public static void Replace(string sourceFileName, string destinationFileName, string destinationBackupFileName) { }
+    public static void Replace(string sourceFileName, string destinationFileName, string destinationBackupFileName, bool ignoreMetadataErrors) { }
+    public static void SetAttributes(string path, System.IO.FileAttributes fileAttributes) { }
+    public static void SetCreationTime(string path, System.DateTime creationTime) { }
+    public static void SetCreationTimeUtc(string path, System.DateTime creationTimeUtc) { }
+    public static void SetLastAccessTime(string path, System.DateTime lastAccessTime) { }
+    public static void SetLastAccessTimeUtc(string path, System.DateTime lastAccessTimeUtc) { }
+    public static void SetLastWriteTime(string path, System.DateTime lastWriteTime) { }
+    public static void SetLastWriteTimeUtc(string path, System.DateTime lastWriteTimeUtc) { }
+    public static void WriteAllBytes(string path, byte[] bytes) { }
+    public static void WriteAllLines(string path, System.Collections.Generic.IEnumerable<string> contents) { }
+    public static void WriteAllLines(string path, System.Collections.Generic.IEnumerable<string> contents, System.Text.Encoding encoding) { }
+    public static void WriteAllLines(string path, string[] contents) { }
+    public static void WriteAllLines(string path, string[] contents, System.Text.Encoding encoding) { }
+    public static void WriteAllText(string path, string contents) { }
+    public static void WriteAllText(string path, string contents, System.Text.Encoding encoding) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class FileInfo : System.IO.FileSystemInfo {
+    public FileInfo(string fileName) { }
+    public System.IO.DirectoryInfo Directory { get { return default(System.IO.DirectoryInfo); } }
+    public string DirectoryName { get { return default(string); } }
+    public override bool Exists { get { return default(bool); } }
+    public bool IsReadOnly { get { return default(bool); } set { } }
+    public long Length { get { return default(long); } }
+    public override string Name { get { return default(string); } }
+    public System.IO.StreamWriter AppendText() { return default(System.IO.StreamWriter); }
+    public System.IO.FileInfo CopyTo(string destFileName) { return default(System.IO.FileInfo); }
+    public System.IO.FileInfo CopyTo(string destFileName, bool overwrite) { return default(System.IO.FileInfo); }
+    public System.IO.FileStream Create() { return default(System.IO.FileStream); }
+    public System.IO.StreamWriter CreateText() { return default(System.IO.StreamWriter); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void Decrypt() { }
+    public override void Delete() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void Encrypt() { }
+    public void MoveTo(string destFileName) { }
+    public System.IO.FileStream Open(System.IO.FileMode mode) { return default(System.IO.FileStream); }
+    public System.IO.FileStream Open(System.IO.FileMode mode, System.IO.FileAccess access) { return default(System.IO.FileStream); }
+    public System.IO.FileStream Open(System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share) { return default(System.IO.FileStream); }
+    public System.IO.FileStream OpenRead() { return default(System.IO.FileStream); }
+    public System.IO.StreamReader OpenText() { return default(System.IO.StreamReader); }
+    public System.IO.FileStream OpenWrite() { return default(System.IO.FileStream); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class FileSystemInfo {
+    protected string FullPath;
+    protected string OriginalPath;
+    protected FileSystemInfo() { }
+    protected FileSystemInfo(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public System.IO.FileAttributes Attributes { get { return default(System.IO.FileAttributes); } set { } }
+    public System.DateTime CreationTime { get { return default(System.DateTime); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.DateTime CreationTimeUtc { get { return default(System.DateTime); } set { } }
+    public abstract bool Exists { get; }
+    public string Extension { get { return default(string); } }
+    public virtual string FullName { get { return default(string); } }
+    public System.DateTime LastAccessTime { get { return default(System.DateTime); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.DateTime LastAccessTimeUtc { get { return default(System.DateTime); } set { } }
+    public System.DateTime LastWriteTime { get { return default(System.DateTime); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.DateTime LastWriteTimeUtc { get { return default(System.DateTime); } set { } }
+    public abstract string Name { get; }
+    public abstract void Delete();
+    public void Refresh() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum SearchOption {
+    AllDirectories = 1,
+    TopDirectoryOnly = 0,
+  }
+
+} // end of System.IO
+namespace System.Security.Permissions {
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class FileIOPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public FileIOPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    [System.ObsoleteAttribute("use newer properties")]
+    public string All { get { return default(string); } set { } }
+    public System.Security.Permissions.FileIOPermissionAccess AllFiles { get { return default(System.Security.Permissions.FileIOPermissionAccess); } set { } }
+    public System.Security.Permissions.FileIOPermissionAccess AllLocalFiles { get { return default(System.Security.Permissions.FileIOPermissionAccess); } set { } }
+    public string Append { get { return default(string); } set { } }
+    public string ChangeAccessControl { get { return default(string); } set { } }
+    public string PathDiscovery { get { return default(string); } set { } }
+    public string Read { get { return default(string); } set { } }
+    public string ViewAccessControl { get { return default(string); } set { } }
+    public string ViewAndModify { get { return default(string); } set { } }
+    public string Write { get { return default(string); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+} // end of System.Security.Permissions

fxdac/fxdac/Data/Contracts/System.IO.MemoryMappedFiles.cs

@@ -0,0 +1,102 @@
+[assembly:System.CLSCompliant(true)]
+namespace Microsoft.Win32.SafeHandles {
+  public sealed partial class SafeMemoryMappedFileHandle : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid {
+    public SafeMemoryMappedFileHandle(System.IntPtr preexistingHandle, bool ownsHandle) : base (default(bool)) { }
+    protected override bool ReleaseHandle() { return default(bool); }
+  }
+
+  public sealed partial class SafeMemoryMappedViewHandle : System.Runtime.InteropServices.SafeBuffer {
+    internal SafeMemoryMappedViewHandle() : base (default(bool)) { }
+    protected override bool ReleaseHandle() { return default(bool); }
+  }
+
+} // end of Microsoft.Win32.SafeHandles
+namespace System.IO.MemoryMappedFiles {
+  public partial class MemoryMappedFile : System.IDisposable {
+    internal MemoryMappedFile() { }
+    public Microsoft.Win32.SafeHandles.SafeMemoryMappedFileHandle SafeMemoryMappedFileHandle { get { return default(Microsoft.Win32.SafeHandles.SafeMemoryMappedFileHandle); } }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateFromFile(System.IO.FileStream fileStream, string mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access, System.IO.MemoryMappedFiles.MemoryMappedFileSecurity memoryMappedFileSecurity, System.IO.HandleInheritability inheritability, bool leaveOpen) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateFromFile(string path) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateFromFile(string path, System.IO.FileMode mode) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateFromFile(string path, System.IO.FileMode mode, string mapName) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateFromFile(string path, System.IO.FileMode mode, string mapName, long capacity) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateFromFile(string path, System.IO.FileMode mode, string mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateNew(string mapName, long capacity) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateNew(string mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateNew(string mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access, System.IO.MemoryMappedFiles.MemoryMappedFileOptions options, System.IO.MemoryMappedFiles.MemoryMappedFileSecurity memoryMappedFileSecurity, System.IO.HandleInheritability inheritability) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateOrOpen(string mapName, long capacity) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateOrOpen(string mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile CreateOrOpen(string mapName, long capacity, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access, System.IO.MemoryMappedFiles.MemoryMappedFileOptions options, System.IO.MemoryMappedFiles.MemoryMappedFileSecurity memoryMappedFileSecurity, System.IO.HandleInheritability inheritability) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public System.IO.MemoryMappedFiles.MemoryMappedViewAccessor CreateViewAccessor() { return default(System.IO.MemoryMappedFiles.MemoryMappedViewAccessor); }
+    public System.IO.MemoryMappedFiles.MemoryMappedViewAccessor CreateViewAccessor(long offset, long size) { return default(System.IO.MemoryMappedFiles.MemoryMappedViewAccessor); }
+    public System.IO.MemoryMappedFiles.MemoryMappedViewAccessor CreateViewAccessor(long offset, long size, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access) { return default(System.IO.MemoryMappedFiles.MemoryMappedViewAccessor); }
+    public System.IO.MemoryMappedFiles.MemoryMappedViewStream CreateViewStream() { return default(System.IO.MemoryMappedFiles.MemoryMappedViewStream); }
+    public System.IO.MemoryMappedFiles.MemoryMappedViewStream CreateViewStream(long offset, long size) { return default(System.IO.MemoryMappedFiles.MemoryMappedViewStream); }
+    public System.IO.MemoryMappedFiles.MemoryMappedViewStream CreateViewStream(long offset, long size, System.IO.MemoryMappedFiles.MemoryMappedFileAccess access) { return default(System.IO.MemoryMappedFiles.MemoryMappedViewStream); }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public System.IO.MemoryMappedFiles.MemoryMappedFileSecurity GetAccessControl() { return default(System.IO.MemoryMappedFiles.MemoryMappedFileSecurity); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile OpenExisting(string mapName) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile OpenExisting(string mapName, System.IO.MemoryMappedFiles.MemoryMappedFileRights desiredAccessRights) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public static System.IO.MemoryMappedFiles.MemoryMappedFile OpenExisting(string mapName, System.IO.MemoryMappedFiles.MemoryMappedFileRights desiredAccessRights, System.IO.HandleInheritability inheritability) { return default(System.IO.MemoryMappedFiles.MemoryMappedFile); }
+    public void SetAccessControl(System.IO.MemoryMappedFiles.MemoryMappedFileSecurity memoryMappedFileSecurity) { }
+  }
+
+  public enum MemoryMappedFileAccess {
+    CopyOnWrite = 3,
+    Read = 1,
+    ReadExecute = 4,
+    ReadWrite = 0,
+    ReadWriteExecute = 5,
+    Write = 2,
+  }
+
+  [System.FlagsAttribute]
+  public enum MemoryMappedFileOptions {
+    DelayAllocatePages = 67108864,
+    None = 0,
+  }
+
+  [System.FlagsAttribute]
+  public enum MemoryMappedFileRights {
+    AccessSystemSecurity = 16777216,
+    ChangePermissions = 262144,
+    CopyOnWrite = 1,
+    Delete = 65536,
+    Execute = 8,
+    FullControl = 983055,
+    Read = 4,
+    ReadExecute = 12,
+    ReadPermissions = 131072,
+    ReadWrite = 6,
+    ReadWriteExecute = 14,
+    TakeOwnership = 524288,
+    Write = 2,
+  }
+
+  public partial class MemoryMappedFileSecurity : System.Security.AccessControl.ObjectSecurity<System.IO.MemoryMappedFiles.MemoryMappedFileRights> {
+    public MemoryMappedFileSecurity() : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+  }
+
+  public sealed partial class MemoryMappedViewAccessor : System.IO.UnmanagedMemoryAccessor {
+    internal MemoryMappedViewAccessor() { }
+    public long PointerOffset { get { return default(long); } }
+    public Microsoft.Win32.SafeHandles.SafeMemoryMappedViewHandle SafeMemoryMappedViewHandle { [System.Security.SecurityCriticalAttribute]get { return default(Microsoft.Win32.SafeHandles.SafeMemoryMappedViewHandle); } }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected override void Dispose(bool disposing) { }
+    [System.Security.SecurityCriticalAttribute]
+    public void Flush() { }
+  }
+
+  public sealed partial class MemoryMappedViewStream : System.IO.UnmanagedMemoryStream {
+    internal MemoryMappedViewStream() { }
+    public long PointerOffset { get { return default(long); } }
+    public Microsoft.Win32.SafeHandles.SafeMemoryMappedViewHandle SafeMemoryMappedViewHandle { [System.Security.SecurityCriticalAttribute]get { return default(Microsoft.Win32.SafeHandles.SafeMemoryMappedViewHandle); } }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected override void Dispose(bool disposing) { }
+    [System.Security.SecurityCriticalAttribute]
+    public override void Flush() { }
+    public override void SetLength(long value) { }
+  }
+
+} // end of System.IO.MemoryMappedFiles

fxdac/fxdac/Data/Contracts/System.IO.UnmanagedMemoryStream.cs

@@ -0,0 +1,131 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.IO {
+  public partial class UnmanagedMemoryAccessor : System.IDisposable {
+    protected UnmanagedMemoryAccessor() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public UnmanagedMemoryAccessor(System.Runtime.InteropServices.SafeBuffer buffer, long offset, long capacity) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public UnmanagedMemoryAccessor(System.Runtime.InteropServices.SafeBuffer buffer, long offset, long capacity, System.IO.FileAccess access) { }
+    public bool CanRead { get { return default(bool); } }
+    public bool CanWrite { get { return default(bool); } }
+    public long Capacity { get { return default(long); } }
+    protected bool IsOpen { get { return default(bool); } }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected void Initialize(System.Runtime.InteropServices.SafeBuffer buffer, long offset, long capacity, System.IO.FileAccess access) { }
+    [System.Security.SecurityCriticalAttribute]
+    public void Read<T>(long position, out T structure) where T : struct { structure = default(T); }
+    [System.Security.SecurityCriticalAttribute]
+    public int ReadArray<T>(long position, T[] array, int offset, int count) where T : struct { return default(int); }
+    public bool ReadBoolean(long position) { return default(bool); }
+    public byte ReadByte(long position) { return default(byte); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public char ReadChar(long position) { return default(char); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public decimal ReadDecimal(long position) { return default(decimal); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public double ReadDouble(long position) { return default(double); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public short ReadInt16(long position) { return default(short); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public int ReadInt32(long position) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public long ReadInt64(long position) { return default(long); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public sbyte ReadSByte(long position) { return default(sbyte); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public float ReadSingle(long position) { return default(float); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public ushort ReadUInt16(long position) { return default(ushort); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public uint ReadUInt32(long position) { return default(uint); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public ulong ReadUInt64(long position) { return default(ulong); }
+    public void Write(long position, bool value) { }
+    public void Write(long position, byte value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, char value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, decimal value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, double value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, short value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, int value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, long value) { }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, sbyte value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, float value) { }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, ushort value) { }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, uint value) { }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Write(long position, ulong value) { }
+    [System.Security.SecurityCriticalAttribute]
+    public void Write<T>(long position, ref T structure) where T : struct { }
+    [System.Security.SecurityCriticalAttribute]
+    public void WriteArray<T>(long position, T[] array, int offset, int count) where T : struct { }
+  }
+
+  public partial class UnmanagedMemoryStream : System.IO.Stream {
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected UnmanagedMemoryStream() { }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe UnmanagedMemoryStream(byte* pointer, long length) { }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe UnmanagedMemoryStream(byte* pointer, long length, long capacity, System.IO.FileAccess access) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public UnmanagedMemoryStream(System.Runtime.InteropServices.SafeBuffer buffer, long offset, long length) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public UnmanagedMemoryStream(System.Runtime.InteropServices.SafeBuffer buffer, long offset, long length, System.IO.FileAccess access) { }
+    public override bool CanRead { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(bool); } }
+    public override bool CanSeek { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(bool); } }
+    public override bool CanWrite { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(bool); } }
+    public long Capacity { get { return default(long); } }
+    public override long Length { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(long); } }
+    public override long Position { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(long); } [System.Security.SecuritySafeCriticalAttribute]set { } }
+    [System.CLSCompliantAttribute(false)]
+    public unsafe byte* PositionPointer { [System.Security.SecurityCriticalAttribute]get { return default(byte*); } [System.Security.SecurityCriticalAttribute]set { } }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected override void Dispose(bool disposing) { }
+    public override void Flush() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task FlushAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    protected unsafe void Initialize(byte* pointer, long length, long capacity, System.IO.FileAccess access) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected void Initialize(System.Runtime.InteropServices.SafeBuffer buffer, long offset, long length, System.IO.FileAccess access) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int Read(byte[] buffer, int offset, int count) { buffer = default(byte[]); return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<int> ReadAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<int>); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int ReadByte() { return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin loc) { return default(long); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override void SetLength(long value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override void Write(byte[] buffer, int offset, int count) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override void WriteByte(byte value) { }
+  }
+
+} // end of System.IO

fxdac/fxdac/Data/Contracts/System.IO.cs

@@ -0,0 +1,397 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.IO {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class BinaryReader : System.IDisposable {
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public BinaryReader(System.IO.Stream input) { }
+    public BinaryReader(System.IO.Stream input, System.Text.Encoding encoding) { }
+    public BinaryReader(System.IO.Stream input, System.Text.Encoding encoding, bool leaveOpen) { }
+    public virtual System.IO.Stream BaseStream { get { return default(System.IO.Stream); } }
+    public virtual void Close() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    protected virtual void FillBuffer(int numBytes) { }
+    public virtual int PeekChar() { return default(int); }
+    public virtual int Read() { return default(int); }
+    public virtual int Read(byte[] buffer, int index, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public virtual int Read(char[] buffer, int index, int count) { return default(int); }
+    protected internal int Read7BitEncodedInt() { return default(int); }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public virtual bool ReadBoolean() { return default(bool); }
+    public virtual byte ReadByte() { return default(byte); }
+    public virtual byte[] ReadBytes(int count) { return default(byte[]); }
+    public virtual char ReadChar() { return default(char); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public virtual char[] ReadChars(int count) { return default(char[]); }
+    public virtual decimal ReadDecimal() { return default(decimal); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public virtual double ReadDouble() { return default(double); }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public virtual short ReadInt16() { return default(short); }
+    public virtual int ReadInt32() { return default(int); }
+    public virtual long ReadInt64() { return default(long); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public virtual sbyte ReadSByte() { return default(sbyte); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public virtual float ReadSingle() { return default(float); }
+    public virtual string ReadString() { return default(string); }
+    [System.CLSCompliantAttribute(false)]
+    public virtual ushort ReadUInt16() { return default(ushort); }
+    [System.CLSCompliantAttribute(false)]
+    public virtual uint ReadUInt32() { return default(uint); }
+    [System.CLSCompliantAttribute(false)]
+    public virtual ulong ReadUInt64() { return default(ulong); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class BinaryWriter : System.IDisposable {
+    public static readonly System.IO.BinaryWriter Null;
+    protected System.IO.Stream OutStream;
+    protected BinaryWriter() { }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public BinaryWriter(System.IO.Stream output) { }
+    public BinaryWriter(System.IO.Stream output, System.Text.Encoding encoding) { }
+    public BinaryWriter(System.IO.Stream output, System.Text.Encoding encoding, bool leaveOpen) { }
+    public virtual System.IO.Stream BaseStream { get { return default(System.IO.Stream); } }
+    public virtual void Close() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public virtual void Flush() { }
+    public virtual long Seek(int offset, System.IO.SeekOrigin origin) { return default(long); }
+    public virtual void Write(bool value) { }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public virtual void Write(byte value) { }
+    public virtual void Write(byte[] buffer) { }
+    public virtual void Write(byte[] buffer, int index, int count) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public virtual void Write(char ch) { }
+    public virtual void Write(char[] chars) { }
+    public virtual void Write(char[] chars, int index, int count) { }
+    public virtual void Write(decimal value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public virtual void Write(double value) { }
+    public virtual void Write(short value) { }
+    public virtual void Write(int value) { }
+    public virtual void Write(long value) { }
+    [System.CLSCompliantAttribute(false)]
+    public virtual void Write(sbyte value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public virtual void Write(float value) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public virtual void Write(string value) { }
+    [System.CLSCompliantAttribute(false)]
+    public virtual void Write(ushort value) { }
+    [System.CLSCompliantAttribute(false)]
+    public virtual void Write(uint value) { }
+    [System.CLSCompliantAttribute(false)]
+    public virtual void Write(ulong value) { }
+    protected void Write7BitEncodedInt(int value) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class BufferedStream : System.IO.Stream {
+    public BufferedStream(System.IO.Stream stream) { }
+    public BufferedStream(System.IO.Stream stream, int bufferSize) { }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    public override long Length { get { return default(long); } }
+    public override long Position { get { return default(long); } set { } }
+    public override System.IAsyncResult BeginRead(byte[] buffer, int offset, int count, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginWrite(byte[] buffer, int offset, int count, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    protected override void Dispose(bool disposing) { }
+    public override int EndRead(System.IAsyncResult asyncResult) { return default(int); }
+    public override void EndWrite(System.IAsyncResult asyncResult) { }
+    public override void Flush() { }
+    public override System.Threading.Tasks.Task FlushAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    public override int Read(byte[] array, int offset, int count) { array = default(byte[]); return default(int); }
+    public override System.Threading.Tasks.Task<int> ReadAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<int>); }
+    public override int ReadByte() { return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin origin) { return default(long); }
+    public override void SetLength(long value) { }
+    public override void Write(byte[] array, int offset, int count) { }
+    public override System.Threading.Tasks.Task WriteAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    public override void WriteByte(byte value) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class MemoryStream : System.IO.Stream {
+    public MemoryStream() { }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public MemoryStream(byte[] buffer) { }
+    public MemoryStream(byte[] buffer, bool writable) { }
+    public MemoryStream(byte[] buffer, int index, int count) { }
+    public MemoryStream(byte[] buffer, int index, int count, bool writable) { }
+    public MemoryStream(byte[] buffer, int index, int count, bool writable, bool publiclyVisible) { }
+    public MemoryStream(int capacity) { }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    public virtual int Capacity { get { return default(int); } set { } }
+    public override long Length { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(long); } }
+    public override long Position { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(long); } set { } }
+    public override System.Threading.Tasks.Task CopyToAsync(System.IO.Stream destination, int bufferSize, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    protected override void Dispose(bool disposing) { }
+    public override void Flush() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task FlushAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public virtual byte[] GetBuffer() { return default(byte[]); }
+    public override int Read(byte[] buffer, int offset, int count) { buffer = default(byte[]); return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<int> ReadAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<int>); }
+    public override int ReadByte() { return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin loc) { return default(long); }
+    public override void SetLength(long value) { }
+    public virtual byte[] ToArray() { return default(byte[]); }
+    public override void Write(byte[] buffer, int offset, int count) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    public override void WriteByte(byte value) { }
+    public virtual void WriteTo(System.IO.Stream stream) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class StreamReader : System.IO.TextReader {
+    public static readonly new System.IO.StreamReader Null;
+    public StreamReader(System.IO.Stream stream) { }
+    public StreamReader(System.IO.Stream stream, bool detectEncodingFromByteOrderMarks) { }
+    public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding) { }
+    public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks) { }
+    public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) { }
+    public StreamReader(System.IO.Stream stream, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen) { }
+    public StreamReader(string path) { }
+    public StreamReader(string path, bool detectEncodingFromByteOrderMarks) { }
+    public StreamReader(string path, System.Text.Encoding encoding) { }
+    public StreamReader(string path, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public StreamReader(string path, System.Text.Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize) { }
+    public virtual System.IO.Stream BaseStream { get { return default(System.IO.Stream); } }
+    public virtual System.Text.Encoding CurrentEncoding { get { return default(System.Text.Encoding); } }
+    public bool EndOfStream { get { return default(bool); } }
+    public override void Close() { }
+    public void DiscardBufferedData() { }
+    protected override void Dispose(bool disposing) { }
+    public override int Peek() { return default(int); }
+    public override int Read() { return default(int); }
+    public override int Read(char[] buffer, int index, int count) { buffer = default(char[]); return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<int> ReadAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task<int>); }
+    public override int ReadBlock(char[] buffer, int index, int count) { buffer = default(char[]); return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<int> ReadBlockAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task<int>); }
+    public override string ReadLine() { return default(string); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<string> ReadLineAsync() { return default(System.Threading.Tasks.Task<string>); }
+    public override string ReadToEnd() { return default(string); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<string> ReadToEndAsync() { return default(System.Threading.Tasks.Task<string>); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class StreamWriter : System.IO.TextWriter {
+    public static readonly new System.IO.StreamWriter Null;
+    public StreamWriter(System.IO.Stream stream) { }
+    public StreamWriter(System.IO.Stream stream, System.Text.Encoding encoding) { }
+    public StreamWriter(System.IO.Stream stream, System.Text.Encoding encoding, int bufferSize) { }
+    public StreamWriter(System.IO.Stream stream, System.Text.Encoding encoding, int bufferSize, bool leaveOpen) { }
+    public StreamWriter(string path) { }
+    public StreamWriter(string path, bool append) { }
+    public StreamWriter(string path, bool append, System.Text.Encoding encoding) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public StreamWriter(string path, bool append, System.Text.Encoding encoding, int bufferSize) { }
+    public virtual bool AutoFlush { get { return default(bool); } set { } }
+    public virtual System.IO.Stream BaseStream { get { return default(System.IO.Stream); } }
+    public override System.Text.Encoding Encoding { get { return default(System.Text.Encoding); } }
+    public override void Close() { }
+    protected override void Dispose(bool disposing) { }
+    public override void Flush() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task FlushAsync() { return default(System.Threading.Tasks.Task); }
+    public override void Write(char value) { }
+    public override void Write(char[] buffer) { }
+    public override void Write(char[] buffer, int index, int count) { }
+    public override void Write(string value) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteAsync(char value) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteAsync(string value) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteLineAsync() { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteLineAsync(char value) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteLineAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteLineAsync(string value) { return default(System.Threading.Tasks.Task); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class StringReader : System.IO.TextReader {
+    public StringReader(string s) { }
+    public override void Close() { }
+    protected override void Dispose(bool disposing) { }
+    public override int Peek() { return default(int); }
+    public override int Read() { return default(int); }
+    public override int Read(char[] buffer, int index, int count) { buffer = default(char[]); return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<int> ReadAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task<int>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<int> ReadBlockAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task<int>); }
+    public override string ReadLine() { return default(string); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<string> ReadLineAsync() { return default(System.Threading.Tasks.Task<string>); }
+    public override string ReadToEnd() { return default(string); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task<string> ReadToEndAsync() { return default(System.Threading.Tasks.Task<string>); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class StringWriter : System.IO.TextWriter {
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public StringWriter() { }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public StringWriter(System.IFormatProvider formatProvider) { }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public StringWriter(System.Text.StringBuilder sb) { }
+    public StringWriter(System.Text.StringBuilder sb, System.IFormatProvider formatProvider) { }
+    public override System.Text.Encoding Encoding { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(System.Text.Encoding); } }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public override void Close() { }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    protected override void Dispose(bool disposing) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task FlushAsync() { return default(System.Threading.Tasks.Task); }
+    public virtual System.Text.StringBuilder GetStringBuilder() { return default(System.Text.StringBuilder); }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public override string ToString() { return default(string); }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public override void Write(char value) { }
+    public override void Write(char[] buffer, int index, int count) { }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public override void Write(string value) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteAsync(char value) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteAsync(string value) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteLineAsync(char value) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteLineAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Threading.Tasks.Task WriteLineAsync(string value) { return default(System.Threading.Tasks.Task); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class TextReader : System.IDisposable {
+    public static readonly System.IO.TextReader Null;
+    protected TextReader() { }
+    public virtual void Close() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public virtual int Peek() { return default(int); }
+    public virtual int Read() { return default(int); }
+    public virtual int Read(char[] buffer, int index, int count) { buffer = default(char[]); return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task<int> ReadAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task<int>); }
+    public virtual int ReadBlock(char[] buffer, int index, int count) { buffer = default(char[]); return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task<int> ReadBlockAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task<int>); }
+    public virtual string ReadLine() { return default(string); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task<string> ReadLineAsync() { return default(System.Threading.Tasks.Task<string>); }
+    public virtual string ReadToEnd() { return default(string); }
+    [System.Diagnostics.DebuggerStepThroughAttribute]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task<string> ReadToEndAsync() { return default(System.Threading.Tasks.Task<string>); }
+    public static System.IO.TextReader Synchronized(System.IO.TextReader reader) { return default(System.IO.TextReader); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class TextWriter : System.IDisposable {
+    protected char[] CoreNewLine;
+    public static readonly System.IO.TextWriter Null;
+    protected TextWriter() { }
+    protected TextWriter(System.IFormatProvider formatProvider) { }
+    public abstract System.Text.Encoding Encoding { get; }
+    public virtual System.IFormatProvider FormatProvider { get { return default(System.IFormatProvider); } }
+    public virtual string NewLine { get { return default(string); } set { } }
+    public virtual void Close() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public virtual void Flush() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task FlushAsync() { return default(System.Threading.Tasks.Task); }
+    public static System.IO.TextWriter Synchronized(System.IO.TextWriter writer) { return default(System.IO.TextWriter); }
+    public virtual void Write(bool value) { }
+    public virtual void Write(char value) { }
+    public virtual void Write(char[] buffer) { }
+    public virtual void Write(char[] buffer, int index, int count) { }
+    public virtual void Write(decimal value) { }
+    public virtual void Write(double value) { }
+    public virtual void Write(int value) { }
+    public virtual void Write(long value) { }
+    public virtual void Write(object value) { }
+    public virtual void Write(float value) { }
+    public virtual void Write(string value) { }
+    public virtual void Write(string format, object arg0) { }
+    public virtual void Write(string format, object arg0, object arg1) { }
+    public virtual void Write(string format, object arg0, object arg1, object arg2) { }
+    public virtual void Write(string format, params object[] arg) { }
+    [System.CLSCompliantAttribute(false)]
+    public virtual void Write(uint value) { }
+    [System.CLSCompliantAttribute(false)]
+    public virtual void Write(ulong value) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task WriteAsync(char value) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task WriteAsync(char[] buffer) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task WriteAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task WriteAsync(string value) { return default(System.Threading.Tasks.Task); }
+    public virtual void WriteLine() { }
+    public virtual void WriteLine(bool value) { }
+    public virtual void WriteLine(char value) { }
+    public virtual void WriteLine(char[] buffer) { }
+    public virtual void WriteLine(char[] buffer, int index, int count) { }
+    public virtual void WriteLine(decimal value) { }
+    public virtual void WriteLine(double value) { }
+    public virtual void WriteLine(int value) { }
+    public virtual void WriteLine(long value) { }
+    public virtual void WriteLine(object value) { }
+    public virtual void WriteLine(float value) { }
+    public virtual void WriteLine(string value) { }
+    public virtual void WriteLine(string format, object arg0) { }
+    public virtual void WriteLine(string format, object arg0, object arg1) { }
+    public virtual void WriteLine(string format, object arg0, object arg1, object arg2) { }
+    public virtual void WriteLine(string format, params object[] arg) { }
+    [System.CLSCompliantAttribute(false)]
+    public virtual void WriteLine(uint value) { }
+    [System.CLSCompliantAttribute(false)]
+    public virtual void WriteLine(ulong value) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task WriteLineAsync() { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task WriteLineAsync(char value) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task WriteLineAsync(char[] buffer) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task WriteLineAsync(char[] buffer, int index, int count) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Threading.Tasks.Task WriteLineAsync(string value) { return default(System.Threading.Tasks.Task); }
+  }
+
+  public sealed partial class InvalidDataException : System.SystemException {
+    public InvalidDataException() { }
+    public InvalidDataException(string message) { }
+    public InvalidDataException(string message, System.Exception innerException) { }
+  }
+
+} // end of System.IO

fxdac/fxdac/Data/Contracts/System.Leftover.cs

@@ -0,0 +1,513 @@
+[assembly:System.CLSCompliant(true)]
+namespace Mono {
+  public static partial class Runtime {
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static string GetDisplayName() { return default(string); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static bool SetGCAllowSynchronousMajor(bool flag) { return default(bool); }
+  }
+
+} // end of Mono
+namespace System {
+  public partial struct ArgIterator {
+    public ArgIterator(System.RuntimeArgumentHandle arglist) { throw new System.NotImplementedException(); }
+    [System.CLSCompliantAttribute(false)]
+    public unsafe ArgIterator(System.RuntimeArgumentHandle arglist, void* ptr) { throw new System.NotImplementedException(); }
+    public void End() { }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    public System.TypedReference GetNextArg() { return default(System.TypedReference); }
+    [System.CLSCompliantAttribute(false)]
+    public System.TypedReference GetNextArg(System.RuntimeTypeHandle rth) { return default(System.TypedReference); }
+    public System.RuntimeTypeHandle GetNextArgType() { return default(System.RuntimeTypeHandle); }
+    public int GetRemainingCount() { return default(int); }
+  }
+
+} // end of System
+namespace System.Runtime.InteropServices {
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("17156360-2F1A-384A-BC52-FDE93C215C5B")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(0))]
+  public partial interface _Assembly {
+    string CodeBase { get; }
+    System.Reflection.MethodInfo EntryPoint { get; }
+    string EscapedCodeBase { get; }
+    string FullName { get; }
+    string Location { get; }
+    event System.Reflection.ModuleResolveEventHandler ModuleResolve;
+    object CreateInstance(string typeName);
+    object CreateInstance(string typeName, bool ignoreCase);
+    object CreateInstance(string typeName, bool ignoreCase, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, object[] args, System.Globalization.CultureInfo culture, object[] activationAttributes);
+    bool Equals(object other);
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    System.Type[] GetExportedTypes();
+    System.IO.FileStream GetFile(string name);
+    System.IO.FileStream[] GetFiles();
+    System.IO.FileStream[] GetFiles(bool getResourceModules);
+    int GetHashCode();
+    System.Reflection.Module[] GetLoadedModules();
+    System.Reflection.Module[] GetLoadedModules(bool getResourceModules);
+    System.Reflection.ManifestResourceInfo GetManifestResourceInfo(string resourceName);
+    string[] GetManifestResourceNames();
+    System.IO.Stream GetManifestResourceStream(string name);
+    System.IO.Stream GetManifestResourceStream(System.Type type, string name);
+    System.Reflection.Module GetModule(string name);
+    System.Reflection.Module[] GetModules();
+    System.Reflection.Module[] GetModules(bool getResourceModules);
+    System.Reflection.AssemblyName GetName();
+    System.Reflection.AssemblyName GetName(bool copiedName);
+    void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
+    System.Reflection.AssemblyName[] GetReferencedAssemblies();
+    System.Reflection.Assembly GetSatelliteAssembly(System.Globalization.CultureInfo culture);
+    System.Reflection.Assembly GetSatelliteAssembly(System.Globalization.CultureInfo culture, System.Version version);
+    System.Type GetType();
+    System.Type GetType(string name);
+    System.Type GetType(string name, bool throwOnError);
+    System.Type GetType(string name, bool throwOnError, bool ignoreCase);
+    System.Type[] GetTypes();
+    bool IsDefined(System.Type attributeType, bool inherit);
+    System.Reflection.Module LoadModule(string moduleName, byte[] rawModule);
+    System.Reflection.Module LoadModule(string moduleName, byte[] rawModule, byte[] rawSymbolStore);
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("B42B6AAC-317E-34D5-9FA9-093BB4160C50")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _AssemblyName {
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("E9A19478-9646-3679-9B10-8411AE1FD57D")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _ConstructorInfo {
+    System.Reflection.MethodAttributes Attributes { get; }
+    System.Reflection.CallingConventions CallingConvention { get; }
+    System.Type DeclaringType { get; }
+    bool IsAbstract { get; }
+    bool IsAssembly { get; }
+    bool IsConstructor { get; }
+    bool IsFamily { get; }
+    bool IsFamilyAndAssembly { get; }
+    bool IsFamilyOrAssembly { get; }
+    bool IsFinal { get; }
+    bool IsHideBySig { get; }
+    bool IsPrivate { get; }
+    bool IsPublic { get; }
+    bool IsSpecialName { get; }
+    bool IsStatic { get; }
+    bool IsVirtual { get; }
+    System.Reflection.MemberTypes MemberType { get; }
+    System.RuntimeMethodHandle MethodHandle { get; }
+    string Name { get; }
+    System.Type ReflectedType { get; }
+    bool Equals(object other);
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    int GetHashCode();
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    System.Reflection.MethodImplAttributes GetMethodImplementationFlags();
+    System.Reflection.ParameterInfo[] GetParameters();
+    System.Type GetType();
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+    object Invoke_2(object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, System.Globalization.CultureInfo culture);
+    object Invoke_3(object obj, object[] parameters);
+    object Invoke_4(System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, System.Globalization.CultureInfo culture);
+    object Invoke_5(object[] parameters);
+    bool IsDefined(System.Type attributeType, bool inherit);
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("9DE59C64-D889-35A1-B897-587D74469E5B")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _EventInfo {
+    System.Reflection.EventAttributes Attributes { get; }
+    System.Type DeclaringType { get; }
+    System.Type EventHandlerType { get; }
+    bool IsMulticast { get; }
+    bool IsSpecialName { get; }
+    System.Reflection.MemberTypes MemberType { get; }
+    string Name { get; }
+    System.Type ReflectedType { get; }
+    void AddEventHandler(object target, System.Delegate handler);
+    bool Equals(object other);
+    System.Reflection.MethodInfo GetAddMethod();
+    System.Reflection.MethodInfo GetAddMethod(bool nonPublic);
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    int GetHashCode();
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    System.Reflection.MethodInfo GetRaiseMethod();
+    System.Reflection.MethodInfo GetRaiseMethod(bool nonPublic);
+    System.Reflection.MethodInfo GetRemoveMethod();
+    System.Reflection.MethodInfo GetRemoveMethod(bool nonPublic);
+    System.Type GetType();
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+    bool IsDefined(System.Type attributeType, bool inherit);
+    void RemoveEventHandler(object target, System.Delegate handler);
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("b36b5c63-42ef-38bc-a07e-0b34c98f164a")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(0))]
+  public partial interface _Exception {
+    string HelpLink { get; set; }
+    System.Exception InnerException { get; }
+    string Message { get; }
+    string Source { get; set; }
+    string StackTrace { get; }
+    System.Reflection.MethodBase TargetSite { get; }
+    bool Equals(object obj);
+    System.Exception GetBaseException();
+    int GetHashCode();
+    void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
+    System.Type GetType();
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("8A7C1442-A9FB-366B-80D8-4939FFA6DBE0")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _FieldInfo {
+    System.Reflection.FieldAttributes Attributes { get; }
+    System.Type DeclaringType { get; }
+    System.RuntimeFieldHandle FieldHandle { get; }
+    System.Type FieldType { get; }
+    bool IsAssembly { get; }
+    bool IsFamily { get; }
+    bool IsFamilyAndAssembly { get; }
+    bool IsFamilyOrAssembly { get; }
+    bool IsInitOnly { get; }
+    bool IsLiteral { get; }
+    bool IsNotSerialized { get; }
+    bool IsPinvokeImpl { get; }
+    bool IsPrivate { get; }
+    bool IsPublic { get; }
+    bool IsSpecialName { get; }
+    bool IsStatic { get; }
+    System.Reflection.MemberTypes MemberType { get; }
+    string Name { get; }
+    System.Type ReflectedType { get; }
+    bool Equals(object other);
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    int GetHashCode();
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    System.Type GetType();
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    object GetValue(object obj);
+    object GetValueDirect(System.TypedReference obj);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+    bool IsDefined(System.Type attributeType, bool inherit);
+    void SetValue(object obj, object value);
+    void SetValue(object obj, object value, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, System.Globalization.CultureInfo culture);
+    void SetValueDirect(System.TypedReference obj, object value);
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("f7102fa9-cabb-3a74-a6da-b4567ef1b079")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _MemberInfo {
+    System.Type DeclaringType { get; }
+    System.Reflection.MemberTypes MemberType { get; }
+    string Name { get; }
+    System.Type ReflectedType { get; }
+    bool Equals(object other);
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    int GetHashCode();
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    System.Type GetType();
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+    bool IsDefined(System.Type attributeType, bool inherit);
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("6240837A-707F-3181-8E98-A36AE086766B")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _MethodBase {
+    System.Reflection.MethodAttributes Attributes { get; }
+    System.Reflection.CallingConventions CallingConvention { get; }
+    System.Type DeclaringType { get; }
+    bool IsAbstract { get; }
+    bool IsAssembly { get; }
+    bool IsConstructor { get; }
+    bool IsFamily { get; }
+    bool IsFamilyAndAssembly { get; }
+    bool IsFamilyOrAssembly { get; }
+    bool IsFinal { get; }
+    bool IsHideBySig { get; }
+    bool IsPrivate { get; }
+    bool IsPublic { get; }
+    bool IsSpecialName { get; }
+    bool IsStatic { get; }
+    bool IsVirtual { get; }
+    System.Reflection.MemberTypes MemberType { get; }
+    System.RuntimeMethodHandle MethodHandle { get; }
+    string Name { get; }
+    System.Type ReflectedType { get; }
+    bool Equals(object other);
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    int GetHashCode();
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    System.Reflection.MethodImplAttributes GetMethodImplementationFlags();
+    System.Reflection.ParameterInfo[] GetParameters();
+    System.Type GetType();
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    object Invoke(object obj, object[] parameters);
+    object Invoke(object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, System.Globalization.CultureInfo culture);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+    bool IsDefined(System.Type attributeType, bool inherit);
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("FFCC1B5D-ECB8-38DD-9B01-3DC8ABC2AA5F")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _MethodInfo {
+    System.Reflection.MethodAttributes Attributes { get; }
+    System.Reflection.CallingConventions CallingConvention { get; }
+    System.Type DeclaringType { get; }
+    bool IsAbstract { get; }
+    bool IsAssembly { get; }
+    bool IsConstructor { get; }
+    bool IsFamily { get; }
+    bool IsFamilyAndAssembly { get; }
+    bool IsFamilyOrAssembly { get; }
+    bool IsFinal { get; }
+    bool IsHideBySig { get; }
+    bool IsPrivate { get; }
+    bool IsPublic { get; }
+    bool IsSpecialName { get; }
+    bool IsStatic { get; }
+    bool IsVirtual { get; }
+    System.Reflection.MemberTypes MemberType { get; }
+    System.RuntimeMethodHandle MethodHandle { get; }
+    string Name { get; }
+    System.Type ReflectedType { get; }
+    System.Type ReturnType { get; }
+    System.Reflection.ICustomAttributeProvider ReturnTypeCustomAttributes { get; }
+    bool Equals(object other);
+    System.Reflection.MethodInfo GetBaseDefinition();
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    int GetHashCode();
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    System.Reflection.MethodImplAttributes GetMethodImplementationFlags();
+    System.Reflection.ParameterInfo[] GetParameters();
+    System.Type GetType();
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    object Invoke(object obj, object[] parameters);
+    object Invoke(object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] parameters, System.Globalization.CultureInfo culture);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+    bool IsDefined(System.Type attributeType, bool inherit);
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("D002E9BA-D9E3-3749-B1D3-D565A08B13E7")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _Module {
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("993634C4-E47A-32CC-BE08-85F567DC27D6")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _ParameterInfo {
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("F59ED4E4-E68F-3218-BD77-061AA82824BF")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _PropertyInfo {
+    System.Reflection.PropertyAttributes Attributes { get; }
+    bool CanRead { get; }
+    bool CanWrite { get; }
+    System.Type DeclaringType { get; }
+    bool IsSpecialName { get; }
+    System.Reflection.MemberTypes MemberType { get; }
+    string Name { get; }
+    System.Type PropertyType { get; }
+    System.Type ReflectedType { get; }
+    bool Equals(object other);
+    System.Reflection.MethodInfo[] GetAccessors();
+    System.Reflection.MethodInfo[] GetAccessors(bool nonPublic);
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    System.Reflection.MethodInfo GetGetMethod();
+    System.Reflection.MethodInfo GetGetMethod(bool nonPublic);
+    int GetHashCode();
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    System.Reflection.ParameterInfo[] GetIndexParameters();
+    System.Reflection.MethodInfo GetSetMethod();
+    System.Reflection.MethodInfo GetSetMethod(bool nonPublic);
+    System.Type GetType();
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    object GetValue(object obj, object[] index);
+    object GetValue(object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] index, System.Globalization.CultureInfo culture);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+    bool IsDefined(System.Type attributeType, bool inherit);
+    void SetValue(object obj, object value, object[] index);
+    void SetValue(object obj, object value, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object[] index, System.Globalization.CultureInfo culture);
+    string ToString();
+  }
+
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("BCA8B44D-AAD6-3A86-8AB7-03349F4F2DA2")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _Type {
+    System.Reflection.Assembly Assembly { get; }
+    string AssemblyQualifiedName { get; }
+    System.Reflection.TypeAttributes Attributes { get; }
+    System.Type BaseType { get; }
+    System.Type DeclaringType { get; }
+    string FullName { get; }
+    System.Guid GUID { get; }
+    bool HasElementType { get; }
+    bool IsAbstract { get; }
+    bool IsAnsiClass { get; }
+    bool IsArray { get; }
+    bool IsAutoClass { get; }
+    bool IsAutoLayout { get; }
+    bool IsByRef { get; }
+    bool IsClass { get; }
+    bool IsCOMObject { get; }
+    bool IsContextful { get; }
+    bool IsEnum { get; }
+    bool IsExplicitLayout { get; }
+    bool IsImport { get; }
+    bool IsInterface { get; }
+    bool IsLayoutSequential { get; }
+    bool IsMarshalByRef { get; }
+    bool IsNestedAssembly { get; }
+    bool IsNestedFamANDAssem { get; }
+    bool IsNestedFamily { get; }
+    bool IsNestedFamORAssem { get; }
+    bool IsNestedPrivate { get; }
+    bool IsNestedPublic { get; }
+    bool IsNotPublic { get; }
+    bool IsPointer { get; }
+    bool IsPrimitive { get; }
+    bool IsPublic { get; }
+    bool IsSealed { get; }
+    bool IsSerializable { get; }
+    bool IsSpecialName { get; }
+    bool IsUnicodeClass { get; }
+    bool IsValueType { get; }
+    System.Reflection.MemberTypes MemberType { get; }
+    System.Reflection.Module Module { get; }
+    string Name { get; }
+    string Namespace { get; }
+    System.Type ReflectedType { get; }
+    System.RuntimeTypeHandle TypeHandle { get; }
+    System.Reflection.ConstructorInfo TypeInitializer { get; }
+    System.Type UnderlyingSystemType { get; }
+    bool Equals(object other);
+    bool Equals(System.Type o);
+    System.Type[] FindInterfaces(System.Reflection.TypeFilter filter, object filterCriteria);
+    System.Reflection.MemberInfo[] FindMembers(System.Reflection.MemberTypes memberType, System.Reflection.BindingFlags bindingAttr, System.Reflection.MemberFilter filter, object filterCriteria);
+    int GetArrayRank();
+    System.Reflection.ConstructorInfo GetConstructor(System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Reflection.CallingConventions callConvention, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
+    System.Reflection.ConstructorInfo GetConstructor(System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
+    System.Reflection.ConstructorInfo GetConstructor(System.Type[] types);
+    System.Reflection.ConstructorInfo[] GetConstructors();
+    System.Reflection.ConstructorInfo[] GetConstructors(System.Reflection.BindingFlags bindingAttr);
+    object[] GetCustomAttributes(bool inherit);
+    object[] GetCustomAttributes(System.Type attributeType, bool inherit);
+    System.Reflection.MemberInfo[] GetDefaultMembers();
+    System.Type GetElementType();
+    System.Reflection.EventInfo GetEvent(string name);
+    System.Reflection.EventInfo GetEvent(string name, System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.EventInfo[] GetEvents();
+    System.Reflection.EventInfo[] GetEvents(System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.FieldInfo GetField(string name);
+    System.Reflection.FieldInfo GetField(string name, System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.FieldInfo[] GetFields();
+    System.Reflection.FieldInfo[] GetFields(System.Reflection.BindingFlags bindingAttr);
+    int GetHashCode();
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    System.Type GetInterface(string name);
+    System.Type GetInterface(string name, bool ignoreCase);
+    System.Reflection.InterfaceMapping GetInterfaceMap(System.Type interfaceType);
+    System.Type[] GetInterfaces();
+    System.Reflection.MemberInfo[] GetMember(string name);
+    System.Reflection.MemberInfo[] GetMember(string name, System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.MemberInfo[] GetMember(string name, System.Reflection.MemberTypes type, System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.MemberInfo[] GetMembers();
+    System.Reflection.MemberInfo[] GetMembers(System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.MethodInfo GetMethod(string name);
+    System.Reflection.MethodInfo GetMethod(string name, System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.MethodInfo GetMethod(string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Reflection.CallingConventions callConvention, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
+    System.Reflection.MethodInfo GetMethod(string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
+    System.Reflection.MethodInfo GetMethod(string name, System.Type[] types);
+    System.Reflection.MethodInfo GetMethod(string name, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
+    System.Reflection.MethodInfo[] GetMethods();
+    System.Reflection.MethodInfo[] GetMethods(System.Reflection.BindingFlags bindingAttr);
+    System.Type GetNestedType(string name);
+    System.Type GetNestedType(string name, System.Reflection.BindingFlags bindingAttr);
+    System.Type[] GetNestedTypes();
+    System.Type[] GetNestedTypes(System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.PropertyInfo[] GetProperties();
+    System.Reflection.PropertyInfo[] GetProperties(System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.PropertyInfo GetProperty(string name);
+    System.Reflection.PropertyInfo GetProperty(string name, System.Reflection.BindingFlags bindingAttr);
+    System.Reflection.PropertyInfo GetProperty(string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Type returnType, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
+    System.Reflection.PropertyInfo GetProperty(string name, System.Type returnType);
+    System.Reflection.PropertyInfo GetProperty(string name, System.Type returnType, System.Type[] types);
+    System.Reflection.PropertyInfo GetProperty(string name, System.Type returnType, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
+    System.Reflection.PropertyInfo GetProperty(string name, System.Type[] types);
+    System.Type GetType();
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+    object InvokeMember(string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args);
+    object InvokeMember(string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Globalization.CultureInfo culture);
+    object InvokeMember(string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Reflection.ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters);
+    bool IsAssignableFrom(System.Type c);
+    bool IsDefined(System.Type attributeType, bool inherit);
+    bool IsInstanceOfType(object o);
+    bool IsSubclassOf(System.Type c);
+    string ToString();
+  }
+
+} // end of System.Runtime.InteropServices

fxdac/fxdac/Data/Contracts/System.Linq.Parallel.cs

@@ -0,0 +1,250 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Linq {
+  public partial class OrderedParallelQuery<TSource> : System.Linq.ParallelQuery<TSource> {
+    internal OrderedParallelQuery() { }
+    public override System.Collections.Generic.IEnumerator<TSource> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<TSource>); }
+  }
+
+  public static partial class ParallelEnumerable {
+    public static TSource Aggregate<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TSource, TSource> func) { return default(TSource); }
+    public static TAccumulate Aggregate<TSource, TAccumulate>(this System.Linq.ParallelQuery<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> func) { return default(TAccumulate); }
+    public static TResult Aggregate<TSource, TAccumulate, TResult>(this System.Linq.ParallelQuery<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> updateAccumulatorFunc, System.Func<TAccumulate, TAccumulate, TAccumulate> combineAccumulatorsFunc, System.Func<TAccumulate, TResult> resultSelector) { return default(TResult); }
+    public static TResult Aggregate<TSource, TAccumulate, TResult>(this System.Linq.ParallelQuery<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> func, System.Func<TAccumulate, TResult> resultSelector) { return default(TResult); }
+    public static TResult Aggregate<TSource, TAccumulate, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TAccumulate> seedFactory, System.Func<TAccumulate, TSource, TAccumulate> updateAccumulatorFunc, System.Func<TAccumulate, TAccumulate, TAccumulate> combineAccumulatorsFunc, System.Func<TAccumulate, TResult> resultSelector) { return default(TResult); }
+    public static bool All<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(bool); }
+    public static bool Any<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(bool); }
+    public static bool Any<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(bool); }
+    public static System.Collections.Generic.IEnumerable<TSource> AsEnumerable<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Linq.ParallelQuery AsOrdered(this System.Linq.ParallelQuery source) { return default(System.Linq.ParallelQuery); }
+    public static System.Linq.ParallelQuery<TSource> AsOrdered<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery AsParallel(this System.Collections.IEnumerable source) { return default(System.Linq.ParallelQuery); }
+    public static System.Linq.ParallelQuery<TSource> AsParallel<TSource>(this System.Collections.Concurrent.Partitioner<TSource> source) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> AsParallel<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> AsSequential<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> AsUnordered<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static decimal Average(this System.Linq.ParallelQuery<decimal> source) { return default(decimal); }
+    public static double Average(this System.Linq.ParallelQuery<double> source) { return default(double); }
+    public static double Average(this System.Linq.ParallelQuery<int> source) { return default(double); }
+    public static double Average(this System.Linq.ParallelQuery<long> source) { return default(double); }
+    public static System.Nullable<decimal> Average(this System.Linq.ParallelQuery<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Average(this System.Linq.ParallelQuery<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average(this System.Linq.ParallelQuery<System.Nullable<int>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average(this System.Linq.ParallelQuery<System.Nullable<long>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<float> Average(this System.Linq.ParallelQuery<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Average(this System.Linq.ParallelQuery<float> source) { return default(float); }
+    public static decimal Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, decimal> selector) { return default(decimal); }
+    public static double Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, double> selector) { return default(double); }
+    public static double Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int> selector) { return default(double); }
+    public static double Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, long> selector) { return default(double); }
+    public static System.Nullable<decimal> Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<decimal>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<double>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<int>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<long>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<float> Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<float>> selector) { return default(System.Nullable<float>); }
+    public static float Average<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, float> selector) { return default(float); }
+    public static System.Linq.ParallelQuery<TResult> Cast<TResult>(this System.Linq.ParallelQuery source) { return default(System.Linq.ParallelQuery<TResult>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TSource> Concat<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Concat<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static bool Contains<TSource>(this System.Linq.ParallelQuery<TSource> source, TSource value) { return default(bool); }
+    public static bool Contains<TSource>(this System.Linq.ParallelQuery<TSource> source, TSource value, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(bool); }
+    public static int Count<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(int); }
+    public static int Count<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(int); }
+    public static System.Linq.ParallelQuery<TSource> DefaultIfEmpty<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> DefaultIfEmpty<TSource>(this System.Linq.ParallelQuery<TSource> source, TSource defaultValue) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Distinct<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Distinct<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static TSource ElementAt<TSource>(this System.Linq.ParallelQuery<TSource> source, int index) { return default(TSource); }
+    public static TSource ElementAtOrDefault<TSource>(this System.Linq.ParallelQuery<TSource> source, int index) { return default(TSource); }
+    public static System.Linq.ParallelQuery<TResult> Empty<TResult>() { return default(System.Linq.ParallelQuery<TResult>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TSource> Except<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(System.Linq.ParallelQuery<TSource>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TSource> Except<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Except<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Except<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static TSource First<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource); }
+    public static TSource First<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static TSource FirstOrDefault<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource); }
+    public static TSource FirstOrDefault<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static void ForAll<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Action<TSource> action) { }
+    public static System.Linq.ParallelQuery<System.Linq.IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.ParallelQuery<System.Linq.IGrouping<TKey, TSource>>); }
+    public static System.Linq.ParallelQuery<System.Linq.IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ParallelQuery<System.Linq.IGrouping<TKey, TSource>>); }
+    public static System.Linq.ParallelQuery<System.Linq.IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { return default(System.Linq.ParallelQuery<System.Linq.IGrouping<TKey, TElement>>); }
+    public static System.Linq.ParallelQuery<System.Linq.IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ParallelQuery<System.Linq.IGrouping<TKey, TElement>>); }
+    public static System.Linq.ParallelQuery<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ParallelQuery<TResult>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.ParallelQuery<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.ParallelQuery<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.ParallelQuery<TOuter> outer, System.Linq.ParallelQuery<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.ParallelQuery<TOuter> outer, System.Linq.ParallelQuery<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ParallelQuery<TResult>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TSource> Intersect<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(System.Linq.ParallelQuery<TSource>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TSource> Intersect<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Intersect<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Intersect<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.ParallelQuery<TSource>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.ParallelQuery<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.ParallelQuery<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.ParallelQuery<TOuter> outer, System.Linq.ParallelQuery<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.ParallelQuery<TOuter> outer, System.Linq.ParallelQuery<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static TSource Last<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource); }
+    public static TSource Last<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static TSource LastOrDefault<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource); }
+    public static TSource LastOrDefault<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static long LongCount<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(long); }
+    public static long LongCount<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(long); }
+    public static decimal Max(this System.Linq.ParallelQuery<decimal> source) { return default(decimal); }
+    public static double Max(this System.Linq.ParallelQuery<double> source) { return default(double); }
+    public static int Max(this System.Linq.ParallelQuery<int> source) { return default(int); }
+    public static long Max(this System.Linq.ParallelQuery<long> source) { return default(long); }
+    public static System.Nullable<decimal> Max(this System.Linq.ParallelQuery<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Max(this System.Linq.ParallelQuery<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Max(this System.Linq.ParallelQuery<System.Nullable<int>> source) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Max(this System.Linq.ParallelQuery<System.Nullable<long>> source) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Max(this System.Linq.ParallelQuery<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Max(this System.Linq.ParallelQuery<float> source) { return default(float); }
+    public static TSource Max<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource); }
+    public static decimal Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, decimal> selector) { return default(decimal); }
+    public static double Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, double> selector) { return default(double); }
+    public static int Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int> selector) { return default(int); }
+    public static long Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, long> selector) { return default(long); }
+    public static System.Nullable<decimal> Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<decimal>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<double>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<int>> selector) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<long>> selector) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<float>> selector) { return default(System.Nullable<float>); }
+    public static float Max<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, float> selector) { return default(float); }
+    public static TResult Max<TSource, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TResult> selector) { return default(TResult); }
+    public static decimal Min(this System.Linq.ParallelQuery<decimal> source) { return default(decimal); }
+    public static double Min(this System.Linq.ParallelQuery<double> source) { return default(double); }
+    public static int Min(this System.Linq.ParallelQuery<int> source) { return default(int); }
+    public static long Min(this System.Linq.ParallelQuery<long> source) { return default(long); }
+    public static System.Nullable<decimal> Min(this System.Linq.ParallelQuery<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Min(this System.Linq.ParallelQuery<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Min(this System.Linq.ParallelQuery<System.Nullable<int>> source) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Min(this System.Linq.ParallelQuery<System.Nullable<long>> source) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Min(this System.Linq.ParallelQuery<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Min(this System.Linq.ParallelQuery<float> source) { return default(float); }
+    public static TSource Min<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource); }
+    public static decimal Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, decimal> selector) { return default(decimal); }
+    public static double Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, double> selector) { return default(double); }
+    public static int Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int> selector) { return default(int); }
+    public static long Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, long> selector) { return default(long); }
+    public static System.Nullable<decimal> Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<decimal>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<double>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<int>> selector) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<long>> selector) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<float>> selector) { return default(System.Nullable<float>); }
+    public static float Min<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, float> selector) { return default(float); }
+    public static TResult Min<TSource, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TResult> selector) { return default(TResult); }
+    public static System.Linq.ParallelQuery<TResult> OfType<TResult>(this System.Linq.ParallelQuery source) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.OrderedParallelQuery<TSource> OrderBy<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.OrderedParallelQuery<TSource>); }
+    public static System.Linq.OrderedParallelQuery<TSource> OrderBy<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.OrderedParallelQuery<TSource>); }
+    public static System.Linq.OrderedParallelQuery<TSource> OrderByDescending<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.OrderedParallelQuery<TSource>); }
+    public static System.Linq.OrderedParallelQuery<TSource> OrderByDescending<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.OrderedParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<int> Range(int start, int count) { return default(System.Linq.ParallelQuery<int>); }
+    public static System.Linq.ParallelQuery<TResult> Repeat<TResult>(TResult element, int count) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TSource> Reverse<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TResult> Select<TSource, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TResult> selector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> Select<TSource, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int, TResult> selector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> SelectMany<TSource, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Collections.Generic.IEnumerable<TResult>> selector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> SelectMany<TSource, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int, System.Collections.Generic.IEnumerable<TResult>> selector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int, System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static bool SequenceEqual<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(bool); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static bool SequenceEqual<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(bool); }
+    public static bool SequenceEqual<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second) { return default(bool); }
+    public static bool SequenceEqual<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(bool); }
+    public static TSource Single<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource); }
+    public static TSource Single<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static TSource SingleOrDefault<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource); }
+    public static TSource SingleOrDefault<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static System.Linq.ParallelQuery<TSource> Skip<TSource>(this System.Linq.ParallelQuery<TSource> source, int count) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> SkipWhile<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> SkipWhile<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int, bool> predicate) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static decimal Sum(this System.Linq.ParallelQuery<decimal> source) { return default(decimal); }
+    public static double Sum(this System.Linq.ParallelQuery<double> source) { return default(double); }
+    public static int Sum(this System.Linq.ParallelQuery<int> source) { return default(int); }
+    public static long Sum(this System.Linq.ParallelQuery<long> source) { return default(long); }
+    public static System.Nullable<decimal> Sum(this System.Linq.ParallelQuery<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Sum(this System.Linq.ParallelQuery<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Sum(this System.Linq.ParallelQuery<System.Nullable<int>> source) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Sum(this System.Linq.ParallelQuery<System.Nullable<long>> source) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Sum(this System.Linq.ParallelQuery<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Sum(this System.Linq.ParallelQuery<float> source) { return default(float); }
+    public static decimal Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, decimal> selector) { return default(decimal); }
+    public static double Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, double> selector) { return default(double); }
+    public static int Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int> selector) { return default(int); }
+    public static long Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, long> selector) { return default(long); }
+    public static System.Nullable<decimal> Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<decimal>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<double>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<int>> selector) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<long>> selector) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, System.Nullable<float>> selector) { return default(System.Nullable<float>); }
+    public static float Sum<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, float> selector) { return default(float); }
+    public static System.Linq.ParallelQuery<TSource> Take<TSource>(this System.Linq.ParallelQuery<TSource> source, int count) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> TakeWhile<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> TakeWhile<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int, bool> predicate) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.OrderedParallelQuery<TSource> ThenBy<TSource, TKey>(this System.Linq.OrderedParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.OrderedParallelQuery<TSource>); }
+    public static System.Linq.OrderedParallelQuery<TSource> ThenBy<TSource, TKey>(this System.Linq.OrderedParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.OrderedParallelQuery<TSource>); }
+    public static System.Linq.OrderedParallelQuery<TSource> ThenByDescending<TSource, TKey>(this System.Linq.OrderedParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.OrderedParallelQuery<TSource>); }
+    public static System.Linq.OrderedParallelQuery<TSource> ThenByDescending<TSource, TKey>(this System.Linq.OrderedParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.OrderedParallelQuery<TSource>); }
+    public static TSource[] ToArray<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(TSource[]); }
+    public static System.Collections.Generic.Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Collections.Generic.Dictionary<TKey, TSource>); }
+    public static System.Collections.Generic.Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.Dictionary<TKey, TSource>); }
+    public static System.Collections.Generic.Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { return default(System.Collections.Generic.Dictionary<TKey, TElement>); }
+    public static System.Collections.Generic.Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.Dictionary<TKey, TElement>); }
+    public static System.Collections.Generic.List<TSource> ToList<TSource>(this System.Linq.ParallelQuery<TSource> source) { return default(System.Collections.Generic.List<TSource>); }
+    public static System.Linq.ILookup<TKey, TSource> ToLookup<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.ILookup<TKey, TSource>); }
+    public static System.Linq.ILookup<TKey, TSource> ToLookup<TSource, TKey>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ILookup<TKey, TSource>); }
+    public static System.Linq.ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { return default(System.Linq.ILookup<TKey, TElement>); }
+    public static System.Linq.ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ILookup<TKey, TElement>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TSource> Union<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(System.Linq.ParallelQuery<TSource>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TSource> Union<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Union<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Union<TSource>(this System.Linq.ParallelQuery<TSource> first, System.Linq.ParallelQuery<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Where<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, bool> predicate) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> Where<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Func<TSource, int, bool> predicate) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> WithCancellation<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Threading.CancellationToken cancellationToken) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> WithDegreeOfParallelism<TSource>(this System.Linq.ParallelQuery<TSource> source, int degreeOfParallelism) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> WithExecutionMode<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Linq.ParallelExecutionMode executionMode) { return default(System.Linq.ParallelQuery<TSource>); }
+    public static System.Linq.ParallelQuery<TSource> WithMergeOptions<TSource>(this System.Linq.ParallelQuery<TSource> source, System.Linq.ParallelMergeOptions mergeOptions) { return default(System.Linq.ParallelQuery<TSource>); }
+    [System.ObsoleteAttribute("The second data source of a binary operator must be of type System.Linq.ParallelQuery<T> rather than System.Collections.Generic.IEnumerable<T>. To fix this problem, use the AsParallel() extension method to convert the right data source to System.Linq.ParallelQuery<T>.")]
+    public static System.Linq.ParallelQuery<TResult> Zip<TFirst, TSecond, TResult>(this System.Linq.ParallelQuery<TFirst> first, System.Collections.Generic.IEnumerable<TSecond> second, System.Func<TFirst, TSecond, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+    public static System.Linq.ParallelQuery<TResult> Zip<TFirst, TSecond, TResult>(this System.Linq.ParallelQuery<TFirst> first, System.Linq.ParallelQuery<TSecond> second, System.Func<TFirst, TSecond, TResult> resultSelector) { return default(System.Linq.ParallelQuery<TResult>); }
+  }
+
+  public enum ParallelExecutionMode {
+    Default = 0,
+    ForceParallelism = 1,
+  }
+
+  public enum ParallelMergeOptions {
+    AutoBuffered = 2,
+    Default = 0,
+    FullyBuffered = 3,
+    NotBuffered = 1,
+  }
+
+  public partial class ParallelQuery : System.Collections.IEnumerable {
+    internal ParallelQuery() { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public partial class ParallelQuery<TSource> : System.Linq.ParallelQuery, System.Collections.Generic.IEnumerable<TSource>, System.Collections.IEnumerable {
+    internal ParallelQuery() { }
+    public virtual System.Collections.Generic.IEnumerator<TSource> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<TSource>); }
+  }
+
+} // end of System.Linq

fxdac/fxdac/Data/Contracts/System.Linq.Queryable.cs

@@ -0,0 +1,156 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Linq {
+  public abstract partial class EnumerableExecutor {
+    protected EnumerableExecutor() { }
+  }
+
+  public partial class EnumerableExecutor<T> : System.Linq.EnumerableExecutor {
+    public EnumerableExecutor(System.Linq.Expressions.Expression expression) { }
+  }
+
+  public abstract partial class EnumerableQuery {
+    protected EnumerableQuery() { }
+  }
+
+  public partial class EnumerableQuery<T> : System.Linq.EnumerableQuery, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.Linq.IOrderedQueryable, System.Linq.IOrderedQueryable<T>, System.Linq.IQueryable, System.Linq.IQueryable<T>, System.Linq.IQueryProvider {
+    public EnumerableQuery(System.Collections.Generic.IEnumerable<T> enumerable) { }
+    public EnumerableQuery(System.Linq.Expressions.Expression expression) { }
+    System.Type System.Linq.IQueryable.ElementType { get { return default(System.Type); } }
+    System.Linq.Expressions.Expression System.Linq.IQueryable.Expression { get { return default(System.Linq.Expressions.Expression); } }
+    System.Linq.IQueryProvider System.Linq.IQueryable.Provider { get { return default(System.Linq.IQueryProvider); } }
+    System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { return default(System.Collections.Generic.IEnumerator<T>); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    System.Linq.IQueryable System.Linq.IQueryProvider.CreateQuery(System.Linq.Expressions.Expression expression) { return default(System.Linq.IQueryable); }
+    System.Linq.IQueryable<S> System.Linq.IQueryProvider.CreateQuery<S>(System.Linq.Expressions.Expression expression) { return default(System.Linq.IQueryable<S>); }
+    object System.Linq.IQueryProvider.Execute(System.Linq.Expressions.Expression expression) { return default(object); }
+    S System.Linq.IQueryProvider.Execute<S>(System.Linq.Expressions.Expression expression) { return default(S); }
+    public override string ToString() { return default(string); }
+  }
+
+  public static partial class Queryable {
+    public static TSource Aggregate<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TSource, TSource>> func) { return default(TSource); }
+    public static TAccumulate Aggregate<TSource, TAccumulate>(this System.Linq.IQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> func) { return default(TAccumulate); }
+    public static TResult Aggregate<TSource, TAccumulate, TResult>(this System.Linq.IQueryable<TSource> source, TAccumulate seed, System.Linq.Expressions.Expression<System.Func<TAccumulate, TSource, TAccumulate>> func, System.Linq.Expressions.Expression<System.Func<TAccumulate, TResult>> selector) { return default(TResult); }
+    public static bool All<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(bool); }
+    public static bool Any<TSource>(this System.Linq.IQueryable<TSource> source) { return default(bool); }
+    public static bool Any<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(bool); }
+    public static System.Linq.IQueryable AsQueryable(this System.Collections.IEnumerable source) { return default(System.Linq.IQueryable); }
+    public static System.Linq.IQueryable<TElement> AsQueryable<TElement>(this System.Collections.Generic.IEnumerable<TElement> source) { return default(System.Linq.IQueryable<TElement>); }
+    public static decimal Average(this System.Linq.IQueryable<decimal> source) { return default(decimal); }
+    public static double Average(this System.Linq.IQueryable<double> source) { return default(double); }
+    public static double Average(this System.Linq.IQueryable<int> source) { return default(double); }
+    public static double Average(this System.Linq.IQueryable<long> source) { return default(double); }
+    public static System.Nullable<decimal> Average(this System.Linq.IQueryable<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Average(this System.Linq.IQueryable<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average(this System.Linq.IQueryable<System.Nullable<int>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average(this System.Linq.IQueryable<System.Nullable<long>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<float> Average(this System.Linq.IQueryable<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Average(this System.Linq.IQueryable<float> source) { return default(float); }
+    public static decimal Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector) { return default(decimal); }
+    public static double Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector) { return default(double); }
+    public static double Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector) { return default(double); }
+    public static double Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector) { return default(double); }
+    public static System.Nullable<decimal> Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<decimal>>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<double>>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<int>>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<long>>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<float> Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<float>>> selector) { return default(System.Nullable<float>); }
+    public static float Average<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector) { return default(float); }
+    public static System.Linq.IQueryable<TResult> Cast<TResult>(this System.Linq.IQueryable source) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TSource> Concat<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { return default(System.Linq.IQueryable<TSource>); }
+    public static bool Contains<TSource>(this System.Linq.IQueryable<TSource> source, TSource item) { return default(bool); }
+    public static bool Contains<TSource>(this System.Linq.IQueryable<TSource> source, TSource item, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(bool); }
+    public static int Count<TSource>(this System.Linq.IQueryable<TSource> source) { return default(int); }
+    public static int Count<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(int); }
+    public static System.Linq.IQueryable<TSource> DefaultIfEmpty<TSource>(this System.Linq.IQueryable<TSource> source) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> DefaultIfEmpty<TSource>(this System.Linq.IQueryable<TSource> source, TSource defaultValue) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Distinct<TSource>(this System.Linq.IQueryable<TSource> source) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Distinct<TSource>(this System.Linq.IQueryable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.IQueryable<TSource>); }
+    public static TSource ElementAt<TSource>(this System.Linq.IQueryable<TSource> source, int index) { return default(TSource); }
+    public static TSource ElementAtOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, int index) { return default(TSource); }
+    public static System.Linq.IQueryable<TSource> Except<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Except<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.IQueryable<TSource>); }
+    public static TSource First<TSource>(this System.Linq.IQueryable<TSource> source) { return default(TSource); }
+    public static TSource First<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(TSource); }
+    public static TSource FirstOrDefault<TSource>(this System.Linq.IQueryable<TSource> source) { return default(TSource); }
+    public static TSource FirstOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(TSource); }
+    public static System.Linq.IQueryable<System.Linq.IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { return default(System.Linq.IQueryable<System.Linq.IGrouping<TKey, TSource>>); }
+    public static System.Linq.IQueryable<System.Linq.IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.IQueryable<System.Linq.IGrouping<TKey, TSource>>); }
+    public static System.Linq.IQueryable<System.Linq.IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector) { return default(System.Linq.IQueryable<System.Linq.IGrouping<TKey, TElement>>); }
+    public static System.Linq.IQueryable<System.Linq.IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.IQueryable<System.Linq.IGrouping<TKey, TElement>>); }
+    public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult>> resultSelector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult>> resultSelector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult>> resultSelector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TSource> Intersect<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Intersect<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, TResult>> resultSelector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, TInner, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.IQueryable<TResult>); }
+    public static TSource Last<TSource>(this System.Linq.IQueryable<TSource> source) { return default(TSource); }
+    public static TSource Last<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(TSource); }
+    public static TSource LastOrDefault<TSource>(this System.Linq.IQueryable<TSource> source) { return default(TSource); }
+    public static TSource LastOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(TSource); }
+    public static long LongCount<TSource>(this System.Linq.IQueryable<TSource> source) { return default(long); }
+    public static long LongCount<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(long); }
+    public static TSource Max<TSource>(this System.Linq.IQueryable<TSource> source) { return default(TSource); }
+    public static TResult Max<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector) { return default(TResult); }
+    public static TSource Min<TSource>(this System.Linq.IQueryable<TSource> source) { return default(TSource); }
+    public static TResult Min<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector) { return default(TResult); }
+    public static System.Linq.IQueryable<TResult> OfType<TResult>(this System.Linq.IQueryable source) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { return default(System.Linq.IOrderedQueryable<TSource>); }
+    public static System.Linq.IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.IOrderedQueryable<TSource>); }
+    public static System.Linq.IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { return default(System.Linq.IOrderedQueryable<TSource>); }
+    public static System.Linq.IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.IOrderedQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Reverse<TSource>(this System.Linq.IQueryable<TSource> source) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TResult> Select<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TResult>> selector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> Select<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, TResult>> selector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> SelectMany<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IEnumerable<TResult>>> selector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> SelectMany<TSource, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Collections.Generic.IEnumerable<TResult>>> selector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Collections.Generic.IEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, TResult>> resultSelector) { return default(System.Linq.IQueryable<TResult>); }
+    public static System.Linq.IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, System.Collections.Generic.IEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<System.Func<TSource, TCollection, TResult>> resultSelector) { return default(System.Linq.IQueryable<TResult>); }
+    public static bool SequenceEqual<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { return default(bool); }
+    public static bool SequenceEqual<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(bool); }
+    public static TSource Single<TSource>(this System.Linq.IQueryable<TSource> source) { return default(TSource); }
+    public static TSource Single<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(TSource); }
+    public static TSource SingleOrDefault<TSource>(this System.Linq.IQueryable<TSource> source) { return default(TSource); }
+    public static TSource SingleOrDefault<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(TSource); }
+    public static System.Linq.IQueryable<TSource> Skip<TSource>(this System.Linq.IQueryable<TSource> source, int count) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> SkipWhile<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> SkipWhile<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { return default(System.Linq.IQueryable<TSource>); }
+    public static decimal Sum(this System.Linq.IQueryable<decimal> source) { return default(decimal); }
+    public static double Sum(this System.Linq.IQueryable<double> source) { return default(double); }
+    public static int Sum(this System.Linq.IQueryable<int> source) { return default(int); }
+    public static long Sum(this System.Linq.IQueryable<long> source) { return default(long); }
+    public static System.Nullable<decimal> Sum(this System.Linq.IQueryable<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Sum(this System.Linq.IQueryable<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Sum(this System.Linq.IQueryable<System.Nullable<int>> source) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Sum(this System.Linq.IQueryable<System.Nullable<long>> source) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Sum(this System.Linq.IQueryable<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Sum(this System.Linq.IQueryable<float> source) { return default(float); }
+    public static decimal Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, decimal>> selector) { return default(decimal); }
+    public static double Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, double>> selector) { return default(double); }
+    public static int Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int>> selector) { return default(int); }
+    public static long Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, long>> selector) { return default(long); }
+    public static System.Nullable<decimal> Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<decimal>>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<double>>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<int>>> selector) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<long>>> selector) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, System.Nullable<float>>> selector) { return default(System.Nullable<float>); }
+    public static float Sum<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, float>> selector) { return default(float); }
+    public static System.Linq.IQueryable<TSource> Take<TSource>(this System.Linq.IQueryable<TSource> source, int count) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> TakeWhile<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> TakeWhile<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { return default(System.Linq.IOrderedQueryable<TSource>); }
+    public static System.Linq.IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.IOrderedQueryable<TSource>); }
+    public static System.Linq.IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector) { return default(System.Linq.IOrderedQueryable<TSource>); }
+    public static System.Linq.IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.IOrderedQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Union<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Union<TSource>(this System.Linq.IQueryable<TSource> source1, System.Collections.Generic.IEnumerable<TSource> source2, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Where<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TSource> Where<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { return default(System.Linq.IQueryable<TSource>); }
+    public static System.Linq.IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this System.Linq.IQueryable<TFirst> source1, System.Collections.Generic.IEnumerable<TSecond> source2, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, TResult>> resultSelector) { return default(System.Linq.IQueryable<TResult>); }
+  }
+
+} // end of System.Linq

fxdac/fxdac/Data/Contracts/System.Linq.cs

@@ -0,0 +1,207 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Linq {
+  public static partial class Enumerable {
+    public static TSource Aggregate<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TSource, TSource> func) { return default(TSource); }
+    public static TAccumulate Aggregate<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> func) { return default(TAccumulate); }
+    public static TResult Aggregate<TSource, TAccumulate, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate> func, System.Func<TAccumulate, TResult> resultSelector) { return default(TResult); }
+    public static bool All<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(bool); }
+    public static bool Any<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(bool); }
+    public static bool Any<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(bool); }
+    public static System.Collections.Generic.IEnumerable<TSource> AsEnumerable<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static decimal Average(this System.Collections.Generic.IEnumerable<decimal> source) { return default(decimal); }
+    public static double Average(this System.Collections.Generic.IEnumerable<double> source) { return default(double); }
+    public static double Average(this System.Collections.Generic.IEnumerable<int> source) { return default(double); }
+    public static double Average(this System.Collections.Generic.IEnumerable<long> source) { return default(double); }
+    public static System.Nullable<decimal> Average(this System.Collections.Generic.IEnumerable<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Average(this System.Collections.Generic.IEnumerable<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average(this System.Collections.Generic.IEnumerable<System.Nullable<int>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average(this System.Collections.Generic.IEnumerable<System.Nullable<long>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<float> Average(this System.Collections.Generic.IEnumerable<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Average(this System.Collections.Generic.IEnumerable<float> source) { return default(float); }
+    public static decimal Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, decimal> selector) { return default(decimal); }
+    public static double Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, double> selector) { return default(double); }
+    public static double Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int> selector) { return default(double); }
+    public static double Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, long> selector) { return default(double); }
+    public static System.Nullable<decimal> Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<decimal>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<double>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<int>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<double> Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<long>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<float> Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<float>> selector) { return default(System.Nullable<float>); }
+    public static float Average<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, float> selector) { return default(float); }
+    public static System.Collections.Generic.IEnumerable<TResult> Cast<TResult>(this System.Collections.IEnumerable source) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Concat<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static bool Contains<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, TSource value) { return default(bool); }
+    public static bool Contains<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, TSource value, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(bool); }
+    public static int Count<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(int); }
+    public static int Count<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(int); }
+    public static System.Collections.Generic.IEnumerable<TSource> DefaultIfEmpty<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> DefaultIfEmpty<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, TSource defaultValue) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Distinct<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Distinct<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static TSource ElementAt<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, int index) { return default(TSource); }
+    public static TSource ElementAtOrDefault<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, int index) { return default(TSource); }
+    public static System.Collections.Generic.IEnumerable<TResult> Empty<TResult>() { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Except<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Except<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static TSource First<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource); }
+    public static TSource First<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static TSource FirstOrDefault<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource); }
+    public static TSource FirstOrDefault<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>>); }
+    public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>>); }
+    public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { return default(System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>>); }
+    public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>>); }
+    public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult> resultSelector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult> resultSelector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult> resultSelector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Intersect<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Intersect<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, TInner, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static TSource Last<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource); }
+    public static TSource Last<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static TSource LastOrDefault<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource); }
+    public static TSource LastOrDefault<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static long LongCount<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(long); }
+    public static long LongCount<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(long); }
+    public static decimal Max(this System.Collections.Generic.IEnumerable<decimal> source) { return default(decimal); }
+    public static double Max(this System.Collections.Generic.IEnumerable<double> source) { return default(double); }
+    public static int Max(this System.Collections.Generic.IEnumerable<int> source) { return default(int); }
+    public static long Max(this System.Collections.Generic.IEnumerable<long> source) { return default(long); }
+    public static System.Nullable<decimal> Max(this System.Collections.Generic.IEnumerable<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Max(this System.Collections.Generic.IEnumerable<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Max(this System.Collections.Generic.IEnumerable<System.Nullable<int>> source) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Max(this System.Collections.Generic.IEnumerable<System.Nullable<long>> source) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Max(this System.Collections.Generic.IEnumerable<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Max(this System.Collections.Generic.IEnumerable<float> source) { return default(float); }
+    public static TSource Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource); }
+    public static decimal Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, decimal> selector) { return default(decimal); }
+    public static double Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, double> selector) { return default(double); }
+    public static int Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int> selector) { return default(int); }
+    public static long Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, long> selector) { return default(long); }
+    public static System.Nullable<decimal> Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<decimal>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<double>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<int>> selector) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<long>> selector) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<float>> selector) { return default(System.Nullable<float>); }
+    public static float Max<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, float> selector) { return default(float); }
+    public static TResult Max<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TResult> selector) { return default(TResult); }
+    public static decimal Min(this System.Collections.Generic.IEnumerable<decimal> source) { return default(decimal); }
+    public static double Min(this System.Collections.Generic.IEnumerable<double> source) { return default(double); }
+    public static int Min(this System.Collections.Generic.IEnumerable<int> source) { return default(int); }
+    public static long Min(this System.Collections.Generic.IEnumerable<long> source) { return default(long); }
+    public static System.Nullable<decimal> Min(this System.Collections.Generic.IEnumerable<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Min(this System.Collections.Generic.IEnumerable<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Min(this System.Collections.Generic.IEnumerable<System.Nullable<int>> source) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Min(this System.Collections.Generic.IEnumerable<System.Nullable<long>> source) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Min(this System.Collections.Generic.IEnumerable<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Min(this System.Collections.Generic.IEnumerable<float> source) { return default(float); }
+    public static TSource Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource); }
+    public static decimal Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, decimal> selector) { return default(decimal); }
+    public static double Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, double> selector) { return default(double); }
+    public static int Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int> selector) { return default(int); }
+    public static long Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, long> selector) { return default(long); }
+    public static System.Nullable<decimal> Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<decimal>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<double>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<int>> selector) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<long>> selector) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<float>> selector) { return default(System.Nullable<float>); }
+    public static float Min<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, float> selector) { return default(float); }
+    public static TResult Min<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TResult> selector) { return default(TResult); }
+    public static System.Collections.Generic.IEnumerable<TResult> OfType<TResult>(this System.Collections.IEnumerable source) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Linq.IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.IOrderedEnumerable<TSource>); }
+    public static System.Linq.IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.IOrderedEnumerable<TSource>); }
+    public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.IOrderedEnumerable<TSource>); }
+    public static System.Linq.IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.IOrderedEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<int> Range(int start, int count) { return default(System.Collections.Generic.IEnumerable<int>); }
+    public static System.Collections.Generic.IEnumerable<TResult> Repeat<TResult>(TResult element, int count) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Reverse<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TResult> Select<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TResult> selector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> Select<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int, TResult> selector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IEnumerable<TResult>> selector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int, System.Collections.Generic.IEnumerable<TResult>> selector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int, System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, System.Func<TSource, TCollection, TResult> resultSelector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public static bool SequenceEqual<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(bool); }
+    public static bool SequenceEqual<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(bool); }
+    public static TSource Single<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource); }
+    public static TSource Single<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static TSource SingleOrDefault<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource); }
+    public static TSource SingleOrDefault<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(TSource); }
+    public static System.Collections.Generic.IEnumerable<TSource> Skip<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, int count) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> SkipWhile<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> SkipWhile<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static decimal Sum(this System.Collections.Generic.IEnumerable<decimal> source) { return default(decimal); }
+    public static double Sum(this System.Collections.Generic.IEnumerable<double> source) { return default(double); }
+    public static int Sum(this System.Collections.Generic.IEnumerable<int> source) { return default(int); }
+    public static long Sum(this System.Collections.Generic.IEnumerable<long> source) { return default(long); }
+    public static System.Nullable<decimal> Sum(this System.Collections.Generic.IEnumerable<System.Nullable<decimal>> source) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Sum(this System.Collections.Generic.IEnumerable<System.Nullable<double>> source) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Sum(this System.Collections.Generic.IEnumerable<System.Nullable<int>> source) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Sum(this System.Collections.Generic.IEnumerable<System.Nullable<long>> source) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Sum(this System.Collections.Generic.IEnumerable<System.Nullable<float>> source) { return default(System.Nullable<float>); }
+    public static float Sum(this System.Collections.Generic.IEnumerable<float> source) { return default(float); }
+    public static decimal Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, decimal> selector) { return default(decimal); }
+    public static double Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, double> selector) { return default(double); }
+    public static int Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int> selector) { return default(int); }
+    public static long Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, long> selector) { return default(long); }
+    public static System.Nullable<decimal> Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<decimal>> selector) { return default(System.Nullable<decimal>); }
+    public static System.Nullable<double> Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<double>> selector) { return default(System.Nullable<double>); }
+    public static System.Nullable<int> Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<int>> selector) { return default(System.Nullable<int>); }
+    public static System.Nullable<long> Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<long>> selector) { return default(System.Nullable<long>); }
+    public static System.Nullable<float> Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, System.Nullable<float>> selector) { return default(System.Nullable<float>); }
+    public static float Sum<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, float> selector) { return default(float); }
+    public static System.Collections.Generic.IEnumerable<TSource> Take<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, int count) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> TakeWhile<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> TakeWhile<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Linq.IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.IOrderedEnumerable<TSource>); }
+    public static System.Linq.IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this System.Linq.IOrderedEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.IOrderedEnumerable<TSource>); }
+    public static System.Linq.IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.IOrderedEnumerable<TSource>); }
+    public static System.Linq.IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this System.Linq.IOrderedEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer) { return default(System.Linq.IOrderedEnumerable<TSource>); }
+    public static TSource[] ToArray<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(TSource[]); }
+    public static System.Collections.Generic.Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Collections.Generic.Dictionary<TKey, TSource>); }
+    public static System.Collections.Generic.Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.Dictionary<TKey, TSource>); }
+    public static System.Collections.Generic.Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { return default(System.Collections.Generic.Dictionary<TKey, TElement>); }
+    public static System.Collections.Generic.Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Collections.Generic.Dictionary<TKey, TElement>); }
+    public static System.Collections.Generic.List<TSource> ToList<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { return default(System.Collections.Generic.List<TSource>); }
+    public static System.Linq.ILookup<TKey, TSource> ToLookup<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector) { return default(System.Linq.ILookup<TKey, TSource>); }
+    public static System.Linq.ILookup<TKey, TSource> ToLookup<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ILookup<TKey, TSource>); }
+    public static System.Linq.ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { return default(System.Linq.ILookup<TKey, TElement>); }
+    public static System.Linq.ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey> comparer) { return default(System.Linq.ILookup<TKey, TElement>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource> comparer) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { return default(System.Collections.Generic.IEnumerable<TSource>); }
+    public static System.Collections.Generic.IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst> first, System.Collections.Generic.IEnumerable<TSecond> second, System.Func<TFirst, TSecond, TResult> resultSelector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+  }
+
+  public partial interface IGrouping<out TKey, out TElement> : System.Collections.Generic.IEnumerable<TElement>, System.Collections.IEnumerable {
+    TKey Key { get; }
+  }
+
+  public partial interface ILookup<TKey, TElement> : System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>>, System.Collections.IEnumerable {
+    int Count { get; }
+    System.Collections.Generic.IEnumerable<TElement> this[TKey key] { get; }
+    bool Contains(TKey key);
+  }
+
+  public partial interface IOrderedEnumerable<TElement> : System.Collections.Generic.IEnumerable<TElement>, System.Collections.IEnumerable {
+    System.Linq.IOrderedEnumerable<TElement> CreateOrderedEnumerable<TKey>(System.Func<TElement, TKey> keySelector, System.Collections.Generic.IComparer<TKey> comparer, bool descending);
+  }
+
+  public partial class Lookup<TKey, TElement> : System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>>, System.Collections.IEnumerable, System.Linq.ILookup<TKey, TElement> {
+    internal Lookup() { }
+    public int Count { get { return default(int); } }
+    public System.Collections.Generic.IEnumerable<TElement> this[TKey key] { get { return default(System.Collections.Generic.IEnumerable<TElement>); } }
+    [System.Diagnostics.DebuggerHiddenAttribute]
+    public System.Collections.Generic.IEnumerable<TResult> ApplyResultSelector<TResult>(System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult> resultSelector) { return default(System.Collections.Generic.IEnumerable<TResult>); }
+    public bool Contains(TKey key) { return default(bool); }
+    [System.Diagnostics.DebuggerHiddenAttribute]
+    public System.Collections.Generic.IEnumerator<System.Linq.IGrouping<TKey, TElement>> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Linq.IGrouping<TKey, TElement>>); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+} // end of System.Linq

fxdac/fxdac/Data/Contracts/System.Net.HttpListener.cs

@@ -0,0 +1,127 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  public delegate System.Net.AuthenticationSchemes AuthenticationSchemeSelector(System.Net.HttpListenerRequest httpRequest);
+
+  public sealed partial class HttpListener : System.IDisposable {
+    public HttpListener() { }
+    public System.Net.AuthenticationSchemes AuthenticationSchemes { get { return default(System.Net.AuthenticationSchemes); } set { } }
+    public System.Net.AuthenticationSchemeSelector AuthenticationSchemeSelectorDelegate { get { return default(System.Net.AuthenticationSchemeSelector); } set { } }
+    public bool IgnoreWriteExceptions { get { return default(bool); } set { } }
+    public bool IsListening { get { return default(bool); } }
+    public static bool IsSupported { get { return default(bool); } }
+    public System.Net.HttpListenerPrefixCollection Prefixes { get { return default(System.Net.HttpListenerPrefixCollection); } }
+    public string Realm { get { return default(string); } set { } }
+    public bool UnsafeConnectionNtlmAuthentication { get { return default(bool); } set { } }
+    public void Abort() { }
+    public System.IAsyncResult BeginGetContext(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public void Close() { }
+    public System.Net.HttpListenerContext EndGetContext(System.IAsyncResult asyncResult) { return default(System.Net.HttpListenerContext); }
+    public System.Net.HttpListenerContext GetContext() { return default(System.Net.HttpListenerContext); }
+    public System.Threading.Tasks.Task<System.Net.HttpListenerContext> GetContextAsync() { return default(System.Threading.Tasks.Task<System.Net.HttpListenerContext>); }
+    public void Start() { }
+    public void Stop() { }
+    void System.IDisposable.Dispose() { }
+  }
+
+  public partial class HttpListenerBasicIdentity : System.Security.Principal.GenericIdentity {
+    public HttpListenerBasicIdentity(string username, string password) : base (default(string)) { }
+    public virtual string Password { get { return default(string); } }
+  }
+
+  public sealed partial class HttpListenerContext {
+    internal HttpListenerContext() { }
+    public System.Net.HttpListenerRequest Request { get { return default(System.Net.HttpListenerRequest); } }
+    public System.Net.HttpListenerResponse Response { get { return default(System.Net.HttpListenerResponse); } }
+    public System.Security.Principal.IPrincipal User { get { return default(System.Security.Principal.IPrincipal); } }
+    public System.Threading.Tasks.Task<System.Net.WebSockets.HttpListenerWebSocketContext> AcceptWebSocketAsync(string subProtocol) { return default(System.Threading.Tasks.Task<System.Net.WebSockets.HttpListenerWebSocketContext>); }
+    public System.Threading.Tasks.Task<System.Net.WebSockets.HttpListenerWebSocketContext> AcceptWebSocketAsync(string subProtocol, int receiveBufferSize, System.TimeSpan keepAliveInterval) { return default(System.Threading.Tasks.Task<System.Net.WebSockets.HttpListenerWebSocketContext>); }
+    public System.Threading.Tasks.Task<System.Net.WebSockets.HttpListenerWebSocketContext> AcceptWebSocketAsync(string subProtocol, int receiveBufferSize, System.TimeSpan keepAliveInterval, System.ArraySegment<byte> internalBuffer) { return default(System.Threading.Tasks.Task<System.Net.WebSockets.HttpListenerWebSocketContext>); }
+  }
+
+  public partial class HttpListenerException : System.ComponentModel.Win32Exception {
+    public HttpListenerException() { }
+    public HttpListenerException(int errorCode) { }
+    public HttpListenerException(int errorCode, string message) { }
+    protected HttpListenerException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override int ErrorCode { get { return default(int); } }
+  }
+
+  public partial class HttpListenerPrefixCollection : System.Collections.Generic.ICollection<string>, System.Collections.Generic.IEnumerable<string>, System.Collections.IEnumerable {
+    internal HttpListenerPrefixCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public void Add(string uriPrefix) { }
+    public void Clear() { }
+    public bool Contains(string uriPrefix) { return default(bool); }
+    public void CopyTo(System.Array array, int offset) { }
+    public void CopyTo(string[] array, int offset) { }
+    public System.Collections.Generic.IEnumerator<string> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<string>); }
+    public bool Remove(string uriPrefix) { return default(bool); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public sealed partial class HttpListenerRequest {
+    internal HttpListenerRequest() { }
+    public string[] AcceptTypes { get { return default(string[]); } }
+    public int ClientCertificateError { get { return default(int); } }
+    public System.Text.Encoding ContentEncoding { get { return default(System.Text.Encoding); } }
+    public long ContentLength64 { get { return default(long); } }
+    public string ContentType { get { return default(string); } }
+    public System.Net.CookieCollection Cookies { get { return default(System.Net.CookieCollection); } }
+    public bool HasEntityBody { get { return default(bool); } }
+    public System.Collections.Specialized.NameValueCollection Headers { get { return default(System.Collections.Specialized.NameValueCollection); } }
+    public string HttpMethod { get { return default(string); } }
+    public System.IO.Stream InputStream { get { return default(System.IO.Stream); } }
+    public bool IsAuthenticated { get { return default(bool); } }
+    public bool IsLocal { get { return default(bool); } }
+    public bool IsSecureConnection { get { return default(bool); } }
+    public bool IsWebSocketRequest { get { return default(bool); } }
+    public bool KeepAlive { get { return default(bool); } }
+    public System.Net.IPEndPoint LocalEndPoint { get { return default(System.Net.IPEndPoint); } }
+    public System.Version ProtocolVersion { get { return default(System.Version); } }
+    public System.Collections.Specialized.NameValueCollection QueryString { get { return default(System.Collections.Specialized.NameValueCollection); } }
+    public string RawUrl { get { return default(string); } }
+    public System.Net.IPEndPoint RemoteEndPoint { get { return default(System.Net.IPEndPoint); } }
+    public System.Guid RequestTraceIdentifier { get { return default(System.Guid); } }
+    public string ServiceName { get { return default(string); } }
+    public System.Net.TransportContext TransportContext { get { return default(System.Net.TransportContext); } }
+    public System.Uri Url { get { return default(System.Uri); } }
+    public System.Uri UrlReferrer { get { return default(System.Uri); } }
+    public string UserAgent { get { return default(string); } }
+    public string UserHostAddress { get { return default(string); } }
+    public string UserHostName { get { return default(string); } }
+    public string[] UserLanguages { get { return default(string[]); } }
+    public System.IAsyncResult BeginGetClientCertificate(System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    public System.Security.Cryptography.X509Certificates.X509Certificate2 EndGetClientCertificate(System.IAsyncResult asyncResult) { return default(System.Security.Cryptography.X509Certificates.X509Certificate2); }
+    public System.Security.Cryptography.X509Certificates.X509Certificate2 GetClientCertificate() { return default(System.Security.Cryptography.X509Certificates.X509Certificate2); }
+    public System.Threading.Tasks.Task<System.Security.Cryptography.X509Certificates.X509Certificate2> GetClientCertificateAsync() { return default(System.Threading.Tasks.Task<System.Security.Cryptography.X509Certificates.X509Certificate2>); }
+  }
+
+  public sealed partial class HttpListenerResponse : System.IDisposable {
+    internal HttpListenerResponse() { }
+    public System.Text.Encoding ContentEncoding { get { return default(System.Text.Encoding); } set { } }
+    public long ContentLength64 { get { return default(long); } set { } }
+    public string ContentType { get { return default(string); } set { } }
+    public System.Net.CookieCollection Cookies { get { return default(System.Net.CookieCollection); } set { } }
+    public System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } set { } }
+    public bool KeepAlive { get { return default(bool); } set { } }
+    public System.IO.Stream OutputStream { get { return default(System.IO.Stream); } }
+    public System.Version ProtocolVersion { get { return default(System.Version); } set { } }
+    public string RedirectLocation { get { return default(string); } set { } }
+    public bool SendChunked { get { return default(bool); } set { } }
+    public int StatusCode { get { return default(int); } set { } }
+    public string StatusDescription { get { return default(string); } set { } }
+    public void Abort() { }
+    public void AddHeader(string name, string value) { }
+    public void AppendCookie(System.Net.Cookie cookie) { }
+    public void AppendHeader(string name, string value) { }
+    public void Close() { }
+    public void Close(byte[] responseEntity, bool willBlock) { }
+    public void CopyFrom(System.Net.HttpListenerResponse templateResponse) { }
+    public void Redirect(string url) { }
+    public void SetCookie(System.Net.Cookie cookie) { }
+    void System.IDisposable.Dispose() { }
+  }
+
+} // end of System.Net

fxdac/fxdac/Data/Contracts/System.Net.Mail.cs

@@ -0,0 +1,258 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net.Mail {
+  public partial class AlternateView : System.Net.Mail.AttachmentBase {
+    public AlternateView(System.IO.Stream contentStream) : base (default(System.IO.Stream)) { }
+    public AlternateView(System.IO.Stream contentStream, System.Net.Mime.ContentType contentType) : base (default(System.IO.Stream)) { }
+    public AlternateView(System.IO.Stream contentStream, string mediaType) : base (default(System.IO.Stream)) { }
+    public AlternateView(string fileName) : base (default(System.IO.Stream)) { }
+    public AlternateView(string fileName, System.Net.Mime.ContentType contentType) : base (default(System.IO.Stream)) { }
+    public AlternateView(string fileName, string mediaType) : base (default(System.IO.Stream)) { }
+    public System.Uri BaseUri { get { return default(System.Uri); } set { } }
+    public System.Net.Mail.LinkedResourceCollection LinkedResources { get { return default(System.Net.Mail.LinkedResourceCollection); } }
+    public static System.Net.Mail.AlternateView CreateAlternateViewFromString(string content) { return default(System.Net.Mail.AlternateView); }
+    public static System.Net.Mail.AlternateView CreateAlternateViewFromString(string content, System.Net.Mime.ContentType contentType) { return default(System.Net.Mail.AlternateView); }
+    public static System.Net.Mail.AlternateView CreateAlternateViewFromString(string content, System.Text.Encoding encoding, string mediaType) { return default(System.Net.Mail.AlternateView); }
+    protected override void Dispose(bool disposing) { }
+  }
+
+  public sealed partial class AlternateViewCollection : System.Collections.ObjectModel.Collection<System.Net.Mail.AlternateView>, System.IDisposable {
+    internal AlternateViewCollection() { }
+    protected override void ClearItems() { }
+    public void Dispose() { }
+    protected override void InsertItem(int index, System.Net.Mail.AlternateView item) { }
+    protected override void RemoveItem(int index) { }
+    protected override void SetItem(int index, System.Net.Mail.AlternateView item) { }
+  }
+
+  public partial class Attachment : System.Net.Mail.AttachmentBase {
+    public Attachment(System.IO.Stream contentStream, System.Net.Mime.ContentType contentType) : base (default(System.IO.Stream)) { }
+    public Attachment(System.IO.Stream contentStream, string name) : base (default(System.IO.Stream)) { }
+    public Attachment(System.IO.Stream contentStream, string name, string mediaType) : base (default(System.IO.Stream)) { }
+    public Attachment(string fileName) : base (default(System.IO.Stream)) { }
+    public Attachment(string fileName, System.Net.Mime.ContentType contentType) : base (default(System.IO.Stream)) { }
+    public Attachment(string fileName, string mediaType) : base (default(System.IO.Stream)) { }
+    public System.Net.Mime.ContentDisposition ContentDisposition { get { return default(System.Net.Mime.ContentDisposition); } }
+    public string Name { get { return default(string); } set { } }
+    public System.Text.Encoding NameEncoding { get { return default(System.Text.Encoding); } set { } }
+    public static System.Net.Mail.Attachment CreateAttachmentFromString(string content, System.Net.Mime.ContentType contentType) { return default(System.Net.Mail.Attachment); }
+    public static System.Net.Mail.Attachment CreateAttachmentFromString(string content, string name) { return default(System.Net.Mail.Attachment); }
+    public static System.Net.Mail.Attachment CreateAttachmentFromString(string content, string name, System.Text.Encoding contentEncoding, string mediaType) { return default(System.Net.Mail.Attachment); }
+  }
+
+  public abstract partial class AttachmentBase : System.IDisposable {
+    protected AttachmentBase(System.IO.Stream contentStream) { }
+    protected AttachmentBase(System.IO.Stream contentStream, System.Net.Mime.ContentType contentType) { }
+    protected AttachmentBase(System.IO.Stream contentStream, string mediaType) { }
+    protected AttachmentBase(string fileName) { }
+    protected AttachmentBase(string fileName, System.Net.Mime.ContentType contentType) { }
+    protected AttachmentBase(string fileName, string mediaType) { }
+    public string ContentId { get { return default(string); } set { } }
+    public System.IO.Stream ContentStream { get { return default(System.IO.Stream); } }
+    public System.Net.Mime.ContentType ContentType { get { return default(System.Net.Mime.ContentType); } set { } }
+    public System.Net.Mime.TransferEncoding TransferEncoding { get { return default(System.Net.Mime.TransferEncoding); } set { } }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+  }
+
+  public sealed partial class AttachmentCollection : System.Collections.ObjectModel.Collection<System.Net.Mail.Attachment>, System.IDisposable {
+    internal AttachmentCollection() { }
+    protected override void ClearItems() { }
+    public void Dispose() { }
+    protected override void InsertItem(int index, System.Net.Mail.Attachment item) { }
+    protected override void RemoveItem(int index) { }
+    protected override void SetItem(int index, System.Net.Mail.Attachment item) { }
+  }
+
+  [System.FlagsAttribute]
+  public enum DeliveryNotificationOptions {
+    Delay = 4,
+    Never = 134217728,
+    None = 0,
+    OnFailure = 2,
+    OnSuccess = 1,
+  }
+
+  public partial class LinkedResource : System.Net.Mail.AttachmentBase {
+    public LinkedResource(System.IO.Stream contentStream) : base (default(System.IO.Stream)) { }
+    public LinkedResource(System.IO.Stream contentStream, System.Net.Mime.ContentType contentType) : base (default(System.IO.Stream)) { }
+    public LinkedResource(System.IO.Stream contentStream, string mediaType) : base (default(System.IO.Stream)) { }
+    public LinkedResource(string fileName) : base (default(System.IO.Stream)) { }
+    public LinkedResource(string fileName, System.Net.Mime.ContentType contentType) : base (default(System.IO.Stream)) { }
+    public LinkedResource(string fileName, string mediaType) : base (default(System.IO.Stream)) { }
+    public System.Uri ContentLink { get { return default(System.Uri); } set { } }
+    public static System.Net.Mail.LinkedResource CreateLinkedResourceFromString(string content) { return default(System.Net.Mail.LinkedResource); }
+    public static System.Net.Mail.LinkedResource CreateLinkedResourceFromString(string content, System.Net.Mime.ContentType contentType) { return default(System.Net.Mail.LinkedResource); }
+    public static System.Net.Mail.LinkedResource CreateLinkedResourceFromString(string content, System.Text.Encoding contentEncoding, string mediaType) { return default(System.Net.Mail.LinkedResource); }
+  }
+
+  public sealed partial class LinkedResourceCollection : System.Collections.ObjectModel.Collection<System.Net.Mail.LinkedResource>, System.IDisposable {
+    internal LinkedResourceCollection() { }
+    protected override void ClearItems() { }
+    public void Dispose() { }
+    protected override void InsertItem(int index, System.Net.Mail.LinkedResource item) { }
+    protected override void RemoveItem(int index) { }
+    protected override void SetItem(int index, System.Net.Mail.LinkedResource item) { }
+  }
+
+  public partial class MailAddress {
+    public MailAddress(string address) { }
+    public MailAddress(string address, string displayName) { }
+    public MailAddress(string address, string displayName, System.Text.Encoding displayNameEncoding) { }
+    public string Address { get { return default(string); } }
+    public string DisplayName { get { return default(string); } }
+    public string Host { get { return default(string); } }
+    public string User { get { return default(string); } }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  public partial class MailAddressCollection : System.Collections.ObjectModel.Collection<System.Net.Mail.MailAddress> {
+    public MailAddressCollection() { }
+    public void Add(string addresses) { }
+    protected override void InsertItem(int index, System.Net.Mail.MailAddress item) { }
+    protected override void SetItem(int index, System.Net.Mail.MailAddress item) { }
+    public override string ToString() { return default(string); }
+  }
+
+  public partial class MailMessage : System.IDisposable {
+    public MailMessage() { }
+    public MailMessage(System.Net.Mail.MailAddress from, System.Net.Mail.MailAddress to) { }
+    public MailMessage(string from, string to) { }
+    public MailMessage(string from, string to, string subject, string body) { }
+    public System.Net.Mail.AlternateViewCollection AlternateViews { get { return default(System.Net.Mail.AlternateViewCollection); } }
+    public System.Net.Mail.AttachmentCollection Attachments { get { return default(System.Net.Mail.AttachmentCollection); } }
+    public System.Net.Mail.MailAddressCollection Bcc { get { return default(System.Net.Mail.MailAddressCollection); } }
+    public string Body { get { return default(string); } set { } }
+    public System.Text.Encoding BodyEncoding { get { return default(System.Text.Encoding); } set { } }
+    public System.Net.Mail.MailAddressCollection CC { get { return default(System.Net.Mail.MailAddressCollection); } }
+    public System.Net.Mail.DeliveryNotificationOptions DeliveryNotificationOptions { get { return default(System.Net.Mail.DeliveryNotificationOptions); } set { } }
+    public System.Net.Mail.MailAddress From { get { return default(System.Net.Mail.MailAddress); } set { } }
+    public System.Collections.Specialized.NameValueCollection Headers { get { return default(System.Collections.Specialized.NameValueCollection); } }
+    public System.Text.Encoding HeadersEncoding { get { return default(System.Text.Encoding); } set { } }
+    public bool IsBodyHtml { get { return default(bool); } set { } }
+    public System.Net.Mail.MailPriority Priority { get { return default(System.Net.Mail.MailPriority); } set { } }
+    [System.ObsoleteAttribute("Use ReplyToList instead")]
+    public System.Net.Mail.MailAddress ReplyTo { get { return default(System.Net.Mail.MailAddress); } set { } }
+    public System.Net.Mail.MailAddressCollection ReplyToList { get { return default(System.Net.Mail.MailAddressCollection); } }
+    public System.Net.Mail.MailAddress Sender { get { return default(System.Net.Mail.MailAddress); } set { } }
+    public string Subject { get { return default(string); } set { } }
+    public System.Text.Encoding SubjectEncoding { get { return default(System.Text.Encoding); } set { } }
+    public System.Net.Mail.MailAddressCollection To { get { return default(System.Net.Mail.MailAddressCollection); } }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+  }
+
+  public enum MailPriority {
+    High = 2,
+    Low = 1,
+    Normal = 0,
+  }
+
+  public delegate void SendCompletedEventHandler(object sender, System.ComponentModel.AsyncCompletedEventArgs e);
+
+  public enum SmtpAccess {
+    Connect = 1,
+    ConnectToUnrestrictedPort = 2,
+    None = 0,
+  }
+
+  public partial class SmtpClient : System.IDisposable {
+    public SmtpClient() { }
+    public SmtpClient(string host) { }
+    public SmtpClient(string host, int port) { }
+    public System.Security.Cryptography.X509Certificates.X509CertificateCollection ClientCertificates { get { return default(System.Security.Cryptography.X509Certificates.X509CertificateCollection); } }
+    public System.Net.ICredentialsByHost Credentials { get { return default(System.Net.ICredentialsByHost); } set { } }
+    public System.Net.Mail.SmtpDeliveryMethod DeliveryMethod { get { return default(System.Net.Mail.SmtpDeliveryMethod); } set { } }
+    public bool EnableSsl { get { return default(bool); } set { } }
+    public string Host { get { return default(string); } set { } }
+    public string PickupDirectoryLocation { get { return default(string); } set { } }
+    public int Port { get { return default(int); } set { } }
+    public System.Net.ServicePoint ServicePoint { get { return default(System.Net.ServicePoint); } }
+    public string TargetName { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(string); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public int Timeout { get { return default(int); } set { } }
+    public bool UseDefaultCredentials { get { return default(bool); } set { } }
+    public event System.Net.Mail.SendCompletedEventHandler SendCompleted { add { } remove { } }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    protected void OnSendCompleted(System.ComponentModel.AsyncCompletedEventArgs e) { }
+    public void Send(System.Net.Mail.MailMessage message) { }
+    public void Send(string from, string to, string subject, string body) { }
+    public void SendAsync(System.Net.Mail.MailMessage message, object userToken) { }
+    public void SendAsync(string from, string to, string subject, string body, object userToken) { }
+    public void SendAsyncCancel() { }
+    public System.Threading.Tasks.Task SendMailAsync(System.Net.Mail.MailMessage message) { return default(System.Threading.Tasks.Task); }
+    public System.Threading.Tasks.Task SendMailAsync(string from, string recipients, string subject, string body) { return default(System.Threading.Tasks.Task); }
+  }
+
+  public enum SmtpDeliveryMethod {
+    Network = 0,
+    PickupDirectoryFromIis = 2,
+    SpecifiedPickupDirectory = 1,
+  }
+
+  public partial class SmtpException : System.Exception, System.Runtime.Serialization.ISerializable {
+    public SmtpException() { }
+    public SmtpException(System.Net.Mail.SmtpStatusCode statusCode) { }
+    public SmtpException(System.Net.Mail.SmtpStatusCode statusCode, string message) { }
+    protected SmtpException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public SmtpException(string message) { }
+    public SmtpException(string message, System.Exception innerException) { }
+    public System.Net.Mail.SmtpStatusCode StatusCode { get { return default(System.Net.Mail.SmtpStatusCode); } set { } }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+  }
+
+  public partial class SmtpFailedRecipientException : System.Net.Mail.SmtpException, System.Runtime.Serialization.ISerializable {
+    public SmtpFailedRecipientException() { }
+    public SmtpFailedRecipientException(System.Net.Mail.SmtpStatusCode statusCode, string failedRecipient) { }
+    public SmtpFailedRecipientException(System.Net.Mail.SmtpStatusCode statusCode, string failedRecipient, string serverResponse) { }
+    protected SmtpFailedRecipientException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public SmtpFailedRecipientException(string message) { }
+    public SmtpFailedRecipientException(string message, System.Exception innerException) { }
+    public SmtpFailedRecipientException(string message, string failedRecipient, System.Exception innerException) { }
+    public string FailedRecipient { get { return default(string); } }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  public partial class SmtpFailedRecipientsException : System.Net.Mail.SmtpFailedRecipientException, System.Runtime.Serialization.ISerializable {
+    public SmtpFailedRecipientsException() { }
+    protected SmtpFailedRecipientsException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public SmtpFailedRecipientsException(string message) { }
+    public SmtpFailedRecipientsException(string message, System.Exception innerException) { }
+    public SmtpFailedRecipientsException(string message, System.Net.Mail.SmtpFailedRecipientException[] innerExceptions) { }
+    public System.Net.Mail.SmtpFailedRecipientException[] InnerExceptions { get { return default(System.Net.Mail.SmtpFailedRecipientException[]); } }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+  }
+
+  public enum SmtpStatusCode {
+    BadCommandSequence = 503,
+    CannotVerifyUserWillAttemptDelivery = 252,
+    ClientNotPermitted = 454,
+    CommandNotImplemented = 502,
+    CommandParameterNotImplemented = 504,
+    CommandUnrecognized = 500,
+    ExceededStorageAllocation = 552,
+    GeneralFailure = -1,
+    HelpMessage = 214,
+    InsufficientStorage = 452,
+    LocalErrorInProcessing = 451,
+    MailboxBusy = 450,
+    MailboxNameNotAllowed = 553,
+    MailboxUnavailable = 550,
+    MustIssueStartTlsFirst = 530,
+    Ok = 250,
+    ServiceClosingTransmissionChannel = 221,
+    ServiceNotAvailable = 421,
+    ServiceReady = 220,
+    StartMailInput = 354,
+    SyntaxError = 501,
+    SystemStatus = 211,
+    TransactionFailed = 554,
+    UserNotLocalTryAlternatePath = 551,
+    UserNotLocalWillForward = 251,
+  }
+
+} // end of System.Net.Mail

fxdac/fxdac/Data/Contracts/System.Net.Mime.cs

@@ -0,0 +1,65 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net.Mime {
+  public partial class ContentDisposition {
+    public ContentDisposition() { }
+    public ContentDisposition(string disposition) { }
+    public System.DateTime CreationDate { get { return default(System.DateTime); } set { } }
+    public string DispositionType { get { return default(string); } set { } }
+    public string FileName { get { return default(string); } set { } }
+    public bool Inline { get { return default(bool); } set { } }
+    public System.DateTime ModificationDate { get { return default(System.DateTime); } set { } }
+    public System.Collections.Specialized.StringDictionary Parameters { get { return default(System.Collections.Specialized.StringDictionary); } }
+    public System.DateTime ReadDate { get { return default(System.DateTime); } set { } }
+    public long Size { get { return default(long); } set { } }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  public partial class ContentType {
+    public ContentType() { }
+    public ContentType(string contentType) { }
+    public string Boundary { get { return default(string); } set { } }
+    public string CharSet { get { return default(string); } set { } }
+    public string MediaType { get { return default(string); } set { } }
+    public string Name { get { return default(string); } set { } }
+    public System.Collections.Specialized.StringDictionary Parameters { get { return default(System.Collections.Specialized.StringDictionary); } }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  public static partial class DispositionTypeNames {
+    public const string Attachment = "attachment";
+    public const string Inline = "inline";
+  }
+
+  public static partial class MediaTypeNames {
+    public static partial class Application {
+      public const string Octet = "application/octet-stream";
+      public const string Pdf = "application/pdf";
+      public const string Rtf = "application/rtf";
+      public const string Soap = "application/soap+xml";
+      public const string Zip = "application/zip";
+    }
+    public static partial class Image {
+      public const string Gif = "image/gif";
+      public const string Jpeg = "image/jpeg";
+      public const string Tiff = "image/tiff";
+    }
+    public static partial class Text {
+      public const string Html = "text/html";
+      public const string Plain = "text/plain";
+      public const string RichText = "text/richtext";
+      public const string Xml = "text/xml";
+    }
+  }
+
+  public enum TransferEncoding {
+    Base64 = 1,
+    QuotedPrintable = 0,
+    SevenBit = 2,
+    Unknown = -1,
+  }
+
+} // end of System.Net.Mime

fxdac/fxdac/Data/Contracts/System.Net.NameResolution.cs

@@ -0,0 +1,41 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  public static partial class Dns {
+    public static System.IAsyncResult BeginGetHostAddresses(string hostNameOrAddress, System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    [System.ObsoleteAttribute("Use BeginGetHostEntry instead")]
+    public static System.IAsyncResult BeginGetHostByName(string hostName, System.AsyncCallback requestCallback, object stateObject) { return default(System.IAsyncResult); }
+    public static System.IAsyncResult BeginGetHostEntry(System.Net.IPAddress address, System.AsyncCallback requestCallback, object stateObject) { return default(System.IAsyncResult); }
+    public static System.IAsyncResult BeginGetHostEntry(string hostNameOrAddress, System.AsyncCallback requestCallback, object stateObject) { return default(System.IAsyncResult); }
+    [System.ObsoleteAttribute("Use BeginGetHostEntry instead")]
+    public static System.IAsyncResult BeginResolve(string hostName, System.AsyncCallback requestCallback, object stateObject) { return default(System.IAsyncResult); }
+    public static System.Net.IPAddress[] EndGetHostAddresses(System.IAsyncResult asyncResult) { return default(System.Net.IPAddress[]); }
+    [System.ObsoleteAttribute("Use EndGetHostEntry instead")]
+    public static System.Net.IPHostEntry EndGetHostByName(System.IAsyncResult asyncResult) { return default(System.Net.IPHostEntry); }
+    public static System.Net.IPHostEntry EndGetHostEntry(System.IAsyncResult asyncResult) { return default(System.Net.IPHostEntry); }
+    [System.ObsoleteAttribute("Use EndGetHostEntry instead")]
+    public static System.Net.IPHostEntry EndResolve(System.IAsyncResult asyncResult) { return default(System.Net.IPHostEntry); }
+    public static System.Net.IPAddress[] GetHostAddresses(string hostNameOrAddress) { return default(System.Net.IPAddress[]); }
+    public static System.Threading.Tasks.Task<System.Net.IPAddress[]> GetHostAddressesAsync(string hostNameOrAddress) { return default(System.Threading.Tasks.Task<System.Net.IPAddress[]>); }
+    [System.ObsoleteAttribute("Use GetHostEntry instead")]
+    public static System.Net.IPHostEntry GetHostByAddress(System.Net.IPAddress address) { return default(System.Net.IPHostEntry); }
+    [System.ObsoleteAttribute("Use GetHostEntry instead")]
+    public static System.Net.IPHostEntry GetHostByAddress(string address) { return default(System.Net.IPHostEntry); }
+    [System.ObsoleteAttribute("Use GetHostEntry instead")]
+    public static System.Net.IPHostEntry GetHostByName(string hostName) { return default(System.Net.IPHostEntry); }
+    public static System.Net.IPHostEntry GetHostEntry(System.Net.IPAddress address) { return default(System.Net.IPHostEntry); }
+    public static System.Net.IPHostEntry GetHostEntry(string hostNameOrAddress) { return default(System.Net.IPHostEntry); }
+    public static System.Threading.Tasks.Task<System.Net.IPHostEntry> GetHostEntryAsync(System.Net.IPAddress address) { return default(System.Threading.Tasks.Task<System.Net.IPHostEntry>); }
+    public static System.Threading.Tasks.Task<System.Net.IPHostEntry> GetHostEntryAsync(string hostNameOrAddress) { return default(System.Threading.Tasks.Task<System.Net.IPHostEntry>); }
+    public static string GetHostName() { return default(string); }
+    [System.ObsoleteAttribute("Use GetHostEntry instead")]
+    public static System.Net.IPHostEntry Resolve(string hostName) { return default(System.Net.IPHostEntry); }
+  }
+
+  public partial class IPHostEntry {
+    public IPHostEntry() { }
+    public System.Net.IPAddress[] AddressList { get { return default(System.Net.IPAddress[]); } set { } }
+    public string[] Aliases { get { return default(string[]); } set { } }
+    public string HostName { get { return default(string); } set { } }
+  }
+
+} // end of System.Net

fxdac/fxdac/Data/Contracts/System.Net.NetworkInformation.cs

@@ -0,0 +1,466 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net.NetworkInformation {
+  public enum DuplicateAddressDetectionState {
+    Deprecated = 3,
+    Duplicate = 2,
+    Invalid = 0,
+    Preferred = 4,
+    Tentative = 1,
+  }
+
+  public abstract partial class GatewayIPAddressInformation {
+    protected GatewayIPAddressInformation() { }
+    public abstract System.Net.IPAddress Address { get; }
+  }
+
+  public partial class GatewayIPAddressInformationCollection : System.Collections.Generic.ICollection<System.Net.NetworkInformation.GatewayIPAddressInformation>, System.Collections.Generic.IEnumerable<System.Net.NetworkInformation.GatewayIPAddressInformation>, System.Collections.IEnumerable {
+    protected GatewayIPAddressInformationCollection() { }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsReadOnly { get { return default(bool); } }
+    public virtual System.Net.NetworkInformation.GatewayIPAddressInformation this[int index] { get { return default(System.Net.NetworkInformation.GatewayIPAddressInformation); } }
+    public virtual void Add(System.Net.NetworkInformation.GatewayIPAddressInformation address) { }
+    public virtual void Clear() { }
+    public virtual bool Contains(System.Net.NetworkInformation.GatewayIPAddressInformation address) { return default(bool); }
+    public virtual void CopyTo(System.Net.NetworkInformation.GatewayIPAddressInformation[] array, int offset) { }
+    public virtual System.Collections.Generic.IEnumerator<System.Net.NetworkInformation.GatewayIPAddressInformation> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Net.NetworkInformation.GatewayIPAddressInformation>); }
+    public virtual bool Remove(System.Net.NetworkInformation.GatewayIPAddressInformation address) { return default(bool); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public abstract partial class IcmpV4Statistics {
+    protected IcmpV4Statistics() { }
+    public abstract long AddressMaskRepliesReceived { get; }
+    public abstract long AddressMaskRepliesSent { get; }
+    public abstract long AddressMaskRequestsReceived { get; }
+    public abstract long AddressMaskRequestsSent { get; }
+    public abstract long DestinationUnreachableMessagesReceived { get; }
+    public abstract long DestinationUnreachableMessagesSent { get; }
+    public abstract long EchoRepliesReceived { get; }
+    public abstract long EchoRepliesSent { get; }
+    public abstract long EchoRequestsReceived { get; }
+    public abstract long EchoRequestsSent { get; }
+    public abstract long ErrorsReceived { get; }
+    public abstract long ErrorsSent { get; }
+    public abstract long MessagesReceived { get; }
+    public abstract long MessagesSent { get; }
+    public abstract long ParameterProblemsReceived { get; }
+    public abstract long ParameterProblemsSent { get; }
+    public abstract long RedirectsReceived { get; }
+    public abstract long RedirectsSent { get; }
+    public abstract long SourceQuenchesReceived { get; }
+    public abstract long SourceQuenchesSent { get; }
+    public abstract long TimeExceededMessagesReceived { get; }
+    public abstract long TimeExceededMessagesSent { get; }
+    public abstract long TimestampRepliesReceived { get; }
+    public abstract long TimestampRepliesSent { get; }
+    public abstract long TimestampRequestsReceived { get; }
+    public abstract long TimestampRequestsSent { get; }
+  }
+
+  public abstract partial class IcmpV6Statistics {
+    protected IcmpV6Statistics() { }
+    public abstract long DestinationUnreachableMessagesReceived { get; }
+    public abstract long DestinationUnreachableMessagesSent { get; }
+    public abstract long EchoRepliesReceived { get; }
+    public abstract long EchoRepliesSent { get; }
+    public abstract long EchoRequestsReceived { get; }
+    public abstract long EchoRequestsSent { get; }
+    public abstract long ErrorsReceived { get; }
+    public abstract long ErrorsSent { get; }
+    public abstract long MembershipQueriesReceived { get; }
+    public abstract long MembershipQueriesSent { get; }
+    public abstract long MembershipReductionsReceived { get; }
+    public abstract long MembershipReductionsSent { get; }
+    public abstract long MembershipReportsReceived { get; }
+    public abstract long MembershipReportsSent { get; }
+    public abstract long MessagesReceived { get; }
+    public abstract long MessagesSent { get; }
+    public abstract long NeighborAdvertisementsReceived { get; }
+    public abstract long NeighborAdvertisementsSent { get; }
+    public abstract long NeighborSolicitsReceived { get; }
+    public abstract long NeighborSolicitsSent { get; }
+    public abstract long PacketTooBigMessagesReceived { get; }
+    public abstract long PacketTooBigMessagesSent { get; }
+    public abstract long ParameterProblemsReceived { get; }
+    public abstract long ParameterProblemsSent { get; }
+    public abstract long RedirectsReceived { get; }
+    public abstract long RedirectsSent { get; }
+    public abstract long RouterAdvertisementsReceived { get; }
+    public abstract long RouterAdvertisementsSent { get; }
+    public abstract long RouterSolicitsReceived { get; }
+    public abstract long RouterSolicitsSent { get; }
+    public abstract long TimeExceededMessagesReceived { get; }
+    public abstract long TimeExceededMessagesSent { get; }
+  }
+
+  public abstract partial class IPAddressInformation {
+    protected IPAddressInformation() { }
+    public abstract System.Net.IPAddress Address { get; }
+    public abstract bool IsDnsEligible { get; }
+    public abstract bool IsTransient { get; }
+  }
+
+  public partial class IPAddressInformationCollection : System.Collections.Generic.ICollection<System.Net.NetworkInformation.IPAddressInformation>, System.Collections.Generic.IEnumerable<System.Net.NetworkInformation.IPAddressInformation>, System.Collections.IEnumerable {
+    internal IPAddressInformationCollection() { }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsReadOnly { get { return default(bool); } }
+    public virtual System.Net.NetworkInformation.IPAddressInformation this[int index] { get { return default(System.Net.NetworkInformation.IPAddressInformation); } }
+    public virtual void Add(System.Net.NetworkInformation.IPAddressInformation address) { }
+    public virtual void Clear() { }
+    public virtual bool Contains(System.Net.NetworkInformation.IPAddressInformation address) { return default(bool); }
+    public virtual void CopyTo(System.Net.NetworkInformation.IPAddressInformation[] array, int offset) { }
+    public virtual System.Collections.Generic.IEnumerator<System.Net.NetworkInformation.IPAddressInformation> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Net.NetworkInformation.IPAddressInformation>); }
+    public virtual bool Remove(System.Net.NetworkInformation.IPAddressInformation address) { return default(bool); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public abstract partial class IPGlobalProperties {
+    protected IPGlobalProperties() { }
+    public abstract string DhcpScopeName { get; }
+    public abstract string DomainName { get; }
+    public abstract string HostName { get; }
+    public abstract bool IsWinsProxy { get; }
+    public abstract System.Net.NetworkInformation.NetBiosNodeType NodeType { get; }
+    public abstract System.Net.NetworkInformation.TcpConnectionInformation[] GetActiveTcpConnections();
+    public abstract System.Net.IPEndPoint[] GetActiveTcpListeners();
+    public abstract System.Net.IPEndPoint[] GetActiveUdpListeners();
+    public abstract System.Net.NetworkInformation.IcmpV4Statistics GetIcmpV4Statistics();
+    public abstract System.Net.NetworkInformation.IcmpV6Statistics GetIcmpV6Statistics();
+    public static System.Net.NetworkInformation.IPGlobalProperties GetIPGlobalProperties() { return default(System.Net.NetworkInformation.IPGlobalProperties); }
+    public abstract System.Net.NetworkInformation.IPGlobalStatistics GetIPv4GlobalStatistics();
+    public abstract System.Net.NetworkInformation.IPGlobalStatistics GetIPv6GlobalStatistics();
+    public abstract System.Net.NetworkInformation.TcpStatistics GetTcpIPv4Statistics();
+    public abstract System.Net.NetworkInformation.TcpStatistics GetTcpIPv6Statistics();
+    public abstract System.Net.NetworkInformation.UdpStatistics GetUdpIPv4Statistics();
+    public abstract System.Net.NetworkInformation.UdpStatistics GetUdpIPv6Statistics();
+  }
+
+  public abstract partial class IPGlobalStatistics {
+    protected IPGlobalStatistics() { }
+    public abstract int DefaultTtl { get; }
+    public abstract bool ForwardingEnabled { get; }
+    public abstract int NumberOfInterfaces { get; }
+    public abstract int NumberOfIPAddresses { get; }
+    public abstract int NumberOfRoutes { get; }
+    public abstract long OutputPacketRequests { get; }
+    public abstract long OutputPacketRoutingDiscards { get; }
+    public abstract long OutputPacketsDiscarded { get; }
+    public abstract long OutputPacketsWithNoRoute { get; }
+    public abstract long PacketFragmentFailures { get; }
+    public abstract long PacketReassembliesRequired { get; }
+    public abstract long PacketReassemblyFailures { get; }
+    public abstract long PacketReassemblyTimeout { get; }
+    public abstract long PacketsFragmented { get; }
+    public abstract long PacketsReassembled { get; }
+    public abstract long ReceivedPackets { get; }
+    public abstract long ReceivedPacketsDelivered { get; }
+    public abstract long ReceivedPacketsDiscarded { get; }
+    public abstract long ReceivedPacketsForwarded { get; }
+    public abstract long ReceivedPacketsWithAddressErrors { get; }
+    public abstract long ReceivedPacketsWithHeadersErrors { get; }
+    public abstract long ReceivedPacketsWithUnknownProtocol { get; }
+  }
+
+  public abstract partial class IPInterfaceProperties {
+    protected IPInterfaceProperties() { }
+    public abstract System.Net.NetworkInformation.IPAddressInformationCollection AnycastAddresses { get; }
+    public abstract System.Net.NetworkInformation.IPAddressCollection DhcpServerAddresses { get; }
+    public abstract System.Net.NetworkInformation.IPAddressCollection DnsAddresses { get; }
+    public abstract string DnsSuffix { get; }
+    public abstract System.Net.NetworkInformation.GatewayIPAddressInformationCollection GatewayAddresses { get; }
+    public abstract bool IsDnsEnabled { get; }
+    public abstract bool IsDynamicDnsEnabled { get; }
+    public abstract System.Net.NetworkInformation.MulticastIPAddressInformationCollection MulticastAddresses { get; }
+    public abstract System.Net.NetworkInformation.UnicastIPAddressInformationCollection UnicastAddresses { get; }
+    public abstract System.Net.NetworkInformation.IPAddressCollection WinsServersAddresses { get; }
+    public abstract System.Net.NetworkInformation.IPv4InterfaceProperties GetIPv4Properties();
+    public abstract System.Net.NetworkInformation.IPv6InterfaceProperties GetIPv6Properties();
+  }
+
+  public abstract partial class IPInterfaceStatistics {
+    protected IPInterfaceStatistics() { }
+    public abstract long BytesReceived { get; }
+    public abstract long BytesSent { get; }
+    public abstract long IncomingPacketsDiscarded { get; }
+    public abstract long IncomingPacketsWithErrors { get; }
+    public abstract long IncomingUnknownProtocolPackets { get; }
+    public abstract long NonUnicastPacketsReceived { get; }
+    public abstract long NonUnicastPacketsSent { get; }
+    public abstract long OutgoingPacketsDiscarded { get; }
+    public abstract long OutgoingPacketsWithErrors { get; }
+    public abstract long OutputQueueLength { get; }
+    public abstract long UnicastPacketsReceived { get; }
+    public abstract long UnicastPacketsSent { get; }
+  }
+
+  public abstract partial class IPv4InterfaceProperties {
+    protected IPv4InterfaceProperties() { }
+    public abstract int Index { get; }
+    public abstract bool IsAutomaticPrivateAddressingActive { get; }
+    public abstract bool IsAutomaticPrivateAddressingEnabled { get; }
+    public abstract bool IsDhcpEnabled { get; }
+    public abstract bool IsForwardingEnabled { get; }
+    public abstract int Mtu { get; }
+    public abstract bool UsesWins { get; }
+  }
+
+  public abstract partial class IPv4InterfaceStatistics {
+    protected IPv4InterfaceStatistics() { }
+    public abstract long BytesReceived { get; }
+    public abstract long BytesSent { get; }
+    public abstract long IncomingPacketsDiscarded { get; }
+    public abstract long IncomingPacketsWithErrors { get; }
+    public abstract long IncomingUnknownProtocolPackets { get; }
+    public abstract long NonUnicastPacketsReceived { get; }
+    public abstract long NonUnicastPacketsSent { get; }
+    public abstract long OutgoingPacketsDiscarded { get; }
+    public abstract long OutgoingPacketsWithErrors { get; }
+    public abstract long OutputQueueLength { get; }
+    public abstract long UnicastPacketsReceived { get; }
+    public abstract long UnicastPacketsSent { get; }
+  }
+
+  public abstract partial class IPv6InterfaceProperties {
+    protected IPv6InterfaceProperties() { }
+    public abstract int Index { get; }
+    public abstract int Mtu { get; }
+  }
+
+  public abstract partial class MulticastIPAddressInformation : System.Net.NetworkInformation.IPAddressInformation {
+    protected MulticastIPAddressInformation() { }
+    public abstract long AddressPreferredLifetime { get; }
+    public abstract long AddressValidLifetime { get; }
+    public abstract long DhcpLeaseLifetime { get; }
+    public abstract System.Net.NetworkInformation.DuplicateAddressDetectionState DuplicateAddressDetectionState { get; }
+    public abstract System.Net.NetworkInformation.PrefixOrigin PrefixOrigin { get; }
+    public abstract System.Net.NetworkInformation.SuffixOrigin SuffixOrigin { get; }
+  }
+
+  public partial class MulticastIPAddressInformationCollection : System.Collections.Generic.ICollection<System.Net.NetworkInformation.MulticastIPAddressInformation>, System.Collections.Generic.IEnumerable<System.Net.NetworkInformation.MulticastIPAddressInformation>, System.Collections.IEnumerable {
+    protected internal MulticastIPAddressInformationCollection() { }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsReadOnly { get { return default(bool); } }
+    public virtual System.Net.NetworkInformation.MulticastIPAddressInformation this[int index] { get { return default(System.Net.NetworkInformation.MulticastIPAddressInformation); } }
+    public virtual void Add(System.Net.NetworkInformation.MulticastIPAddressInformation address) { }
+    public virtual void Clear() { }
+    public virtual bool Contains(System.Net.NetworkInformation.MulticastIPAddressInformation address) { return default(bool); }
+    public virtual void CopyTo(System.Net.NetworkInformation.MulticastIPAddressInformation[] array, int offset) { }
+    public virtual System.Collections.Generic.IEnumerator<System.Net.NetworkInformation.MulticastIPAddressInformation> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Net.NetworkInformation.MulticastIPAddressInformation>); }
+    public virtual bool Remove(System.Net.NetworkInformation.MulticastIPAddressInformation address) { return default(bool); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public enum NetBiosNodeType {
+    Broadcast = 1,
+    Hybrid = 8,
+    Mixed = 4,
+    Peer2Peer = 2,
+    Unknown = 0,
+  }
+
+  public delegate void NetworkAddressChangedEventHandler(object sender, System.EventArgs e);
+
+  public delegate void NetworkAvailabilityChangedEventHandler(object sender, System.Net.NetworkInformation.NetworkAvailabilityEventArgs e);
+
+  public partial class NetworkAvailabilityEventArgs : System.EventArgs {
+    internal NetworkAvailabilityEventArgs() { }
+    public bool IsAvailable { get { return default(bool); } }
+  }
+
+  public sealed partial class NetworkChange {
+    public NetworkChange() { }
+    public static event System.Net.NetworkInformation.NetworkAddressChangedEventHandler NetworkAddressChanged { add { } remove { } }
+    public static event System.Net.NetworkInformation.NetworkAvailabilityChangedEventHandler NetworkAvailabilityChanged { add { } remove { } }
+  }
+
+  [System.FlagsAttribute]
+  public enum NetworkInformationAccess {
+    None = 0,
+    Ping = 4,
+    Read = 1,
+  }
+
+  public partial class NetworkInformationException : System.Exception {
+    public NetworkInformationException() { }
+    public NetworkInformationException(int errorCode) { }
+    public int ErrorCode { get { return default(int); } }
+  }
+
+  public abstract partial class NetworkInterface {
+    protected NetworkInterface() { }
+    public abstract string Description { get; }
+    public abstract string Id { get; }
+    public abstract bool IsReceiveOnly { get; }
+    public static int LoopbackInterfaceIndex { get { return default(int); } }
+    public abstract string Name { get; }
+    public abstract System.Net.NetworkInformation.NetworkInterfaceType NetworkInterfaceType { get; }
+    public abstract System.Net.NetworkInformation.OperationalStatus OperationalStatus { get; }
+    public abstract long Speed { get; }
+    public abstract bool SupportsMulticast { get; }
+    public static System.Net.NetworkInformation.NetworkInterface[] GetAllNetworkInterfaces() { return default(System.Net.NetworkInformation.NetworkInterface[]); }
+    public abstract System.Net.NetworkInformation.IPInterfaceProperties GetIPProperties();
+    public abstract System.Net.NetworkInformation.IPv4InterfaceStatistics GetIPv4Statistics();
+    public static bool GetIsNetworkAvailable() { return default(bool); }
+    public static System.Net.IPAddress GetNetMask(System.Net.IPAddress address) { return default(System.Net.IPAddress); }
+    public abstract System.Net.NetworkInformation.PhysicalAddress GetPhysicalAddress();
+    public abstract bool Supports(System.Net.NetworkInformation.NetworkInterfaceComponent networkInterfaceComponent);
+  }
+
+  public enum NetworkInterfaceComponent {
+    IPv4 = 0,
+    IPv6 = 1,
+  }
+
+  public enum NetworkInterfaceType {
+    AsymmetricDsl = 94,
+    Atm = 37,
+    BasicIsdn = 20,
+    Ethernet = 6,
+    Ethernet3Megabit = 26,
+    FastEthernetFx = 69,
+    FastEthernetT = 62,
+    Fddi = 15,
+    GenericModem = 48,
+    GigabitEthernet = 117,
+    HighPerformanceSerialBus = 144,
+    IPOverAtm = 114,
+    Isdn = 63,
+    Loopback = 24,
+    MultiRateSymmetricDsl = 143,
+    Ppp = 23,
+    PrimaryIsdn = 21,
+    RateAdaptDsl = 95,
+    Slip = 28,
+    SymmetricDsl = 96,
+    TokenRing = 9,
+    Tunnel = 131,
+    Unknown = 1,
+    VeryHighSpeedDsl = 97,
+    Wireless80211 = 71,
+  }
+
+  public enum OperationalStatus {
+    Dormant = 5,
+    Down = 2,
+    LowerLayerDown = 7,
+    NotPresent = 6,
+    Testing = 3,
+    Unknown = 4,
+    Up = 1,
+  }
+
+  public partial class PhysicalAddress {
+    public static readonly System.Net.NetworkInformation.PhysicalAddress None;
+    public PhysicalAddress(byte[] address) { }
+    public override bool Equals(object comparand) { return default(bool); }
+    public byte[] GetAddressBytes() { return default(byte[]); }
+    public override int GetHashCode() { return default(int); }
+    public static System.Net.NetworkInformation.PhysicalAddress Parse(string address) { return default(System.Net.NetworkInformation.PhysicalAddress); }
+    public override string ToString() { return default(string); }
+  }
+
+  public enum PrefixOrigin {
+    Dhcp = 3,
+    Manual = 1,
+    Other = 0,
+    RouterAdvertisement = 4,
+    WellKnown = 2,
+  }
+
+  public enum ScopeLevel {
+    Admin = 4,
+    Global = 14,
+    Interface = 1,
+    Link = 2,
+    None = 0,
+    Organization = 8,
+    Site = 5,
+    Subnet = 3,
+  }
+
+  public enum SuffixOrigin {
+    LinkLayerAddress = 4,
+    Manual = 1,
+    OriginDhcp = 3,
+    Other = 0,
+    Random = 5,
+    WellKnown = 2,
+  }
+
+  public abstract partial class TcpConnectionInformation {
+    protected TcpConnectionInformation() { }
+    public abstract System.Net.IPEndPoint LocalEndPoint { get; }
+    public abstract System.Net.IPEndPoint RemoteEndPoint { get; }
+    public abstract System.Net.NetworkInformation.TcpState State { get; }
+  }
+
+  public enum TcpState {
+    Closed = 1,
+    CloseWait = 8,
+    Closing = 9,
+    DeleteTcb = 12,
+    Established = 5,
+    FinWait1 = 6,
+    FinWait2 = 7,
+    LastAck = 10,
+    Listen = 2,
+    SynReceived = 4,
+    SynSent = 3,
+    TimeWait = 11,
+    Unknown = 0,
+  }
+
+  public abstract partial class TcpStatistics {
+    protected TcpStatistics() { }
+    public abstract long ConnectionsAccepted { get; }
+    public abstract long ConnectionsInitiated { get; }
+    public abstract long CumulativeConnections { get; }
+    public abstract long CurrentConnections { get; }
+    public abstract long ErrorsReceived { get; }
+    public abstract long FailedConnectionAttempts { get; }
+    public abstract long MaximumConnections { get; }
+    public abstract long MaximumTransmissionTimeout { get; }
+    public abstract long MinimumTransmissionTimeout { get; }
+    public abstract long ResetConnections { get; }
+    public abstract long ResetsSent { get; }
+    public abstract long SegmentsReceived { get; }
+    public abstract long SegmentsResent { get; }
+    public abstract long SegmentsSent { get; }
+  }
+
+  public abstract partial class UdpStatistics {
+    protected UdpStatistics() { }
+    public abstract long DatagramsReceived { get; }
+    public abstract long DatagramsSent { get; }
+    public abstract long IncomingDatagramsDiscarded { get; }
+    public abstract long IncomingDatagramsWithErrors { get; }
+    public abstract int UdpListeners { get; }
+  }
+
+  public abstract partial class UnicastIPAddressInformation : System.Net.NetworkInformation.IPAddressInformation {
+    protected UnicastIPAddressInformation() { }
+    public abstract long AddressPreferredLifetime { get; }
+    public abstract long AddressValidLifetime { get; }
+    public abstract long DhcpLeaseLifetime { get; }
+    public abstract System.Net.NetworkInformation.DuplicateAddressDetectionState DuplicateAddressDetectionState { get; }
+    public abstract System.Net.IPAddress IPv4Mask { get; }
+    public virtual int PrefixLength { get { return default(int); } }
+    public abstract System.Net.NetworkInformation.PrefixOrigin PrefixOrigin { get; }
+    public abstract System.Net.NetworkInformation.SuffixOrigin SuffixOrigin { get; }
+  }
+
+  public partial class UnicastIPAddressInformationCollection : System.Collections.Generic.ICollection<System.Net.NetworkInformation.UnicastIPAddressInformation>, System.Collections.Generic.IEnumerable<System.Net.NetworkInformation.UnicastIPAddressInformation>, System.Collections.IEnumerable {
+    protected internal UnicastIPAddressInformationCollection() { }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsReadOnly { get { return default(bool); } }
+    public virtual System.Net.NetworkInformation.UnicastIPAddressInformation this[int index] { get { return default(System.Net.NetworkInformation.UnicastIPAddressInformation); } }
+    public virtual void Add(System.Net.NetworkInformation.UnicastIPAddressInformation address) { }
+    public virtual void Clear() { }
+    public virtual bool Contains(System.Net.NetworkInformation.UnicastIPAddressInformation address) { return default(bool); }
+    public virtual void CopyTo(System.Net.NetworkInformation.UnicastIPAddressInformation[] array, int offset) { }
+    public virtual System.Collections.Generic.IEnumerator<System.Net.NetworkInformation.UnicastIPAddressInformation> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Net.NetworkInformation.UnicastIPAddressInformation>); }
+    public virtual bool Remove(System.Net.NetworkInformation.UnicastIPAddressInformation address) { return default(bool); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+} // end of System.Net.NetworkInformation

fxdac/fxdac/Data/Contracts/System.Net.Ping.cs

@@ -0,0 +1,91 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net.NetworkInformation {
+  public enum IPStatus {
+    BadDestination = 11018,
+    BadHeader = 11042,
+    BadOption = 11007,
+    BadRoute = 11012,
+    DestinationHostUnreachable = 11003,
+    DestinationNetworkUnreachable = 11002,
+    DestinationPortUnreachable = 11005,
+    DestinationProhibited = 11004,
+    DestinationProtocolUnreachable = 11004,
+    DestinationScopeMismatch = 11045,
+    DestinationUnreachable = 11040,
+    HardwareError = 11008,
+    IcmpError = 11044,
+    NoResources = 11006,
+    PacketTooBig = 11009,
+    ParameterProblem = 11015,
+    SourceQuench = 11016,
+    Success = 0,
+    TimedOut = 11010,
+    TimeExceeded = 11041,
+    TtlExpired = 11013,
+    TtlReassemblyTimeExceeded = 11014,
+    Unknown = -1,
+    UnrecognizedNextHeader = 11043,
+  }
+
+  public partial class Ping : System.ComponentModel.Component, System.IDisposable {
+    public Ping() { }
+    public event System.Net.NetworkInformation.PingCompletedEventHandler PingCompleted { add { } remove { } }
+    protected void OnPingCompleted(System.Net.NetworkInformation.PingCompletedEventArgs e) { }
+    public System.Net.NetworkInformation.PingReply Send(System.Net.IPAddress address) { return default(System.Net.NetworkInformation.PingReply); }
+    public System.Net.NetworkInformation.PingReply Send(System.Net.IPAddress address, int timeout) { return default(System.Net.NetworkInformation.PingReply); }
+    public System.Net.NetworkInformation.PingReply Send(System.Net.IPAddress address, int timeout, byte[] buffer) { return default(System.Net.NetworkInformation.PingReply); }
+    public System.Net.NetworkInformation.PingReply Send(System.Net.IPAddress address, int timeout, byte[] buffer, System.Net.NetworkInformation.PingOptions options) { return default(System.Net.NetworkInformation.PingReply); }
+    public System.Net.NetworkInformation.PingReply Send(string hostNameOrAddress) { return default(System.Net.NetworkInformation.PingReply); }
+    public System.Net.NetworkInformation.PingReply Send(string hostNameOrAddress, int timeout) { return default(System.Net.NetworkInformation.PingReply); }
+    public System.Net.NetworkInformation.PingReply Send(string hostNameOrAddress, int timeout, byte[] buffer) { return default(System.Net.NetworkInformation.PingReply); }
+    public System.Net.NetworkInformation.PingReply Send(string hostNameOrAddress, int timeout, byte[] buffer, System.Net.NetworkInformation.PingOptions options) { return default(System.Net.NetworkInformation.PingReply); }
+    public void SendAsync(System.Net.IPAddress address, int timeout, byte[] buffer, System.Net.NetworkInformation.PingOptions options, object userToken) { }
+    public void SendAsync(System.Net.IPAddress address, int timeout, byte[] buffer, object userToken) { }
+    public void SendAsync(System.Net.IPAddress address, int timeout, object userToken) { }
+    public void SendAsync(System.Net.IPAddress address, object userToken) { }
+    public void SendAsync(string hostNameOrAddress, int timeout, byte[] buffer, System.Net.NetworkInformation.PingOptions options, object userToken) { }
+    public void SendAsync(string hostNameOrAddress, int timeout, byte[] buffer, object userToken) { }
+    public void SendAsync(string hostNameOrAddress, int timeout, object userToken) { }
+    public void SendAsync(string hostNameOrAddress, object userToken) { }
+    public void SendAsyncCancel() { }
+    public System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply> SendPingAsync(System.Net.IPAddress address) { return default(System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply>); }
+    public System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply> SendPingAsync(System.Net.IPAddress address, int timeout) { return default(System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply>); }
+    public System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply> SendPingAsync(System.Net.IPAddress address, int timeout, byte[] buffer) { return default(System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply>); }
+    public System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply> SendPingAsync(System.Net.IPAddress address, int timeout, byte[] buffer, System.Net.NetworkInformation.PingOptions options) { return default(System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply>); }
+    public System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply> SendPingAsync(string hostNameOrAddress) { return default(System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply>); }
+    public System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply> SendPingAsync(string hostNameOrAddress, int timeout) { return default(System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply>); }
+    public System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply> SendPingAsync(string hostNameOrAddress, int timeout, byte[] buffer) { return default(System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply>); }
+    public System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply> SendPingAsync(string hostNameOrAddress, int timeout, byte[] buffer, System.Net.NetworkInformation.PingOptions options) { return default(System.Threading.Tasks.Task<System.Net.NetworkInformation.PingReply>); }
+    void System.IDisposable.Dispose() { }
+  }
+
+  public partial class PingCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal PingCompletedEventArgs() { }
+    public System.Net.NetworkInformation.PingReply Reply { get { return default(System.Net.NetworkInformation.PingReply); } }
+  }
+
+  public delegate void PingCompletedEventHandler(object sender, System.Net.NetworkInformation.PingCompletedEventArgs e);
+
+  public partial class PingException : System.InvalidOperationException {
+    protected PingException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public PingException(string message) { }
+    public PingException(string message, System.Exception innerException) { }
+  }
+
+  public partial class PingOptions {
+    public PingOptions() { }
+    public PingOptions(int ttl, bool dontFragment) { }
+    public bool DontFragment { get { return default(bool); } set { } }
+    public int Ttl { get { return default(int); } set { } }
+  }
+
+  public partial class PingReply {
+    internal PingReply() { }
+    public System.Net.IPAddress Address { get { return default(System.Net.IPAddress); } }
+    public byte[] Buffer { get { return default(byte[]); } }
+    public System.Net.NetworkInformation.PingOptions Options { get { return default(System.Net.NetworkInformation.PingOptions); } }
+    public long RoundtripTime { get { return default(long); } }
+    public System.Net.NetworkInformation.IPStatus Status { get { return default(System.Net.NetworkInformation.IPStatus); } }
+  }
+
+} // end of System.Net.NetworkInformation

fxdac/fxdac/Data/Contracts/System.Net.Primitives.cs

@@ -0,0 +1,436 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  [System.FlagsAttribute]
+  public enum AuthenticationSchemes {
+    Anonymous = 32768,
+    Basic = 8,
+    Digest = 1,
+    IntegratedWindowsAuthentication = 6,
+    Negotiate = 2,
+    None = 0,
+    Ntlm = 4,
+  }
+
+  public sealed partial 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 { return default(string); } set { } }
+    public System.Uri CommentUri { get { return default(System.Uri); } set { } }
+    public bool Discard { get { return default(bool); } set { } }
+    public string Domain { get { return default(string); } set { } }
+    public bool Expired { get { return default(bool); } set { } }
+    public System.DateTime Expires { get { return default(System.DateTime); } set { } }
+    public bool HttpOnly { get { return default(bool); } set { } }
+    public string Name { get { return default(string); } set { } }
+    public string Path { get { return default(string); } set { } }
+    public string Port { get { return default(string); } set { } }
+    public bool Secure { get { return default(bool); } set { } }
+    public System.DateTime TimeStamp { get { return default(System.DateTime); } }
+    public string Value { get { return default(string); } set { } }
+    public int Version { get { return default(int); } set { } }
+    public override bool Equals(object comparand) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  public partial class CookieCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    public CookieCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Net.Cookie this[int index] { get { return default(System.Net.Cookie); } }
+    public System.Net.Cookie this[string name] { get { return default(System.Net.Cookie); } }
+    public object SyncRoot { get { return default(object); } }
+    public void Add(System.Net.Cookie cookie) { }
+    public void Add(System.Net.CookieCollection cookies) { }
+    public void CopyTo(System.Array array, int index) { }
+    public void CopyTo(System.Net.Cookie[] array, int index) { }
+    public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public partial class CookieContainer {
+    public const int DefaultCookieLengthLimit = 4096;
+    public const int DefaultCookieLimit = 300;
+    public const int DefaultPerDomainCookieLimit = 20;
+    public CookieContainer() { }
+    public CookieContainer(int capacity) { }
+    public CookieContainer(int capacity, int perDomainCapacity, int maxCookieSize) { }
+    public int Capacity { get { return default(int); } set { } }
+    public int Count { get { return default(int); } }
+    public int MaxCookieSize { get { return default(int); } set { } }
+    public int PerDomainCapacity { get { return default(int); } set { } }
+    public void Add(System.Net.Cookie cookie) { }
+    public void Add(System.Net.CookieCollection cookies) { }
+    public void Add(System.Uri uri, System.Net.Cookie cookie) { }
+    public void Add(System.Uri uri, System.Net.CookieCollection cookies) { }
+    public string GetCookieHeader(System.Uri uri) { return default(string); }
+    public System.Net.CookieCollection GetCookies(System.Uri uri) { return default(System.Net.CookieCollection); }
+    public void SetCookies(System.Uri uri, string cookieHeader) { }
+  }
+
+  public partial class CookieException : System.FormatException, System.Runtime.Serialization.ISerializable {
+    public CookieException() { }
+    protected CookieException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  public partial class CredentialCache : System.Collections.IEnumerable, System.Net.ICredentials, System.Net.ICredentialsByHost {
+    public CredentialCache() { }
+    public static System.Net.ICredentials DefaultCredentials { get { return default(System.Net.ICredentials); } }
+    public static System.Net.NetworkCredential DefaultNetworkCredentials { get { return default(System.Net.NetworkCredential); } }
+    public void Add(string host, int port, string authenticationType, System.Net.NetworkCredential credential) { }
+    public void Add(System.Uri uriPrefix, string authType, System.Net.NetworkCredential cred) { }
+    public System.Net.NetworkCredential GetCredential(string host, int port, string authenticationType) { return default(System.Net.NetworkCredential); }
+    public System.Net.NetworkCredential GetCredential(System.Uri uriPrefix, string authType) { return default(System.Net.NetworkCredential); }
+    public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public void Remove(string host, int port, string authenticationType) { }
+    public void Remove(System.Uri uriPrefix, string authType) { }
+  }
+
+  [System.FlagsAttribute]
+  public enum DecompressionMethods {
+    Deflate = 2,
+    GZip = 1,
+    None = 0,
+  }
+
+  public sealed partial class DnsEndPoint : System.Net.EndPoint {
+    public DnsEndPoint(string host, int port) { }
+    public DnsEndPoint(string host, int port, System.Net.Sockets.AddressFamily addressFamily) { }
+    public override System.Net.Sockets.AddressFamily AddressFamily { get { return default(System.Net.Sockets.AddressFamily); } }
+    public string Host { get { return default(string); } }
+    public int Port { get { return default(int); } }
+    public override bool Equals(object comparand) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  public abstract partial class EndPoint {
+    protected EndPoint() { }
+    public virtual System.Net.Sockets.AddressFamily AddressFamily { get { return default(System.Net.Sockets.AddressFamily); } }
+    public virtual System.Net.EndPoint Create(System.Net.SocketAddress socketAddress) { return default(System.Net.EndPoint); }
+    public virtual System.Net.SocketAddress Serialize() { return default(System.Net.SocketAddress); }
+  }
+
+  public enum HttpStatusCode {
+    Accepted = 202,
+    Ambiguous = 300,
+    BadGateway = 502,
+    BadRequest = 400,
+    Conflict = 409,
+    Continue = 100,
+    Created = 201,
+    ExpectationFailed = 417,
+    Forbidden = 403,
+    Found = 302,
+    GatewayTimeout = 504,
+    Gone = 410,
+    HttpVersionNotSupported = 505,
+    InternalServerError = 500,
+    LengthRequired = 411,
+    MethodNotAllowed = 405,
+    Moved = 301,
+    MovedPermanently = 301,
+    MultipleChoices = 300,
+    NoContent = 204,
+    NonAuthoritativeInformation = 203,
+    NotAcceptable = 406,
+    NotFound = 404,
+    NotImplemented = 501,
+    NotModified = 304,
+    OK = 200,
+    PartialContent = 206,
+    PaymentRequired = 402,
+    PreconditionFailed = 412,
+    ProxyAuthenticationRequired = 407,
+    Redirect = 302,
+    RedirectKeepVerb = 307,
+    RedirectMethod = 303,
+    RequestedRangeNotSatisfiable = 416,
+    RequestEntityTooLarge = 413,
+    RequestTimeout = 408,
+    RequestUriTooLong = 414,
+    ResetContent = 205,
+    SeeOther = 303,
+    ServiceUnavailable = 503,
+    SwitchingProtocols = 101,
+    TemporaryRedirect = 307,
+    Unauthorized = 401,
+    UnsupportedMediaType = 415,
+    Unused = 306,
+    UpgradeRequired = 426,
+    UseProxy = 305,
+  }
+
+  public partial interface ICredentials {
+    System.Net.NetworkCredential GetCredential(System.Uri uri, string authType);
+  }
+
+  public partial interface ICredentialsByHost {
+    System.Net.NetworkCredential GetCredential(string host, int port, string authenticationType);
+  }
+
+  public partial class IPAddress {
+    public static readonly System.Net.IPAddress Any;
+    public static readonly System.Net.IPAddress Broadcast;
+    public static readonly System.Net.IPAddress IPv6Any;
+    public static readonly System.Net.IPAddress IPv6Loopback;
+    public static readonly System.Net.IPAddress IPv6None;
+    public static readonly System.Net.IPAddress Loopback;
+    public static readonly System.Net.IPAddress None;
+    public IPAddress(byte[] address) { }
+    public IPAddress(byte[] address, long scopeid) { }
+    public IPAddress(long newAddress) { }
+    [System.ObsoleteAttribute("This property is obsolete. Use GetAddressBytes.")]
+    public long Address { get { return default(long); } set { } }
+    public System.Net.Sockets.AddressFamily AddressFamily { get { return default(System.Net.Sockets.AddressFamily); } }
+    public bool IsIPv6LinkLocal { get { return default(bool); } }
+    public bool IsIPv6Multicast { get { return default(bool); } }
+    public bool IsIPv6SiteLocal { get { return default(bool); } }
+    public bool IsIPv6Teredo { get { return default(bool); } }
+    public long ScopeId { get { return default(long); } set { } }
+    public override bool Equals(object comparand) { return default(bool); }
+    public byte[] GetAddressBytes() { return default(byte[]); }
+    public override int GetHashCode() { return default(int); }
+    public static short HostToNetworkOrder(short host) { return default(short); }
+    public static int HostToNetworkOrder(int host) { return default(int); }
+    public static long HostToNetworkOrder(long host) { return default(long); }
+    public static bool IsLoopback(System.Net.IPAddress address) { return default(bool); }
+    public static short NetworkToHostOrder(short network) { return default(short); }
+    public static int NetworkToHostOrder(int network) { return default(int); }
+    public static long NetworkToHostOrder(long network) { return default(long); }
+    public static System.Net.IPAddress Parse(string ipString) { return default(System.Net.IPAddress); }
+    public override string ToString() { return default(string); }
+    public static bool TryParse(string ipString, out System.Net.IPAddress address) { address = default(System.Net.IPAddress); return default(bool); }
+  }
+
+  public partial class IPEndPoint : System.Net.EndPoint {
+    public const int MaxPort = 65535;
+    public const int MinPort = 0;
+    public IPEndPoint(long address, int port) { }
+    public IPEndPoint(System.Net.IPAddress address, int port) { }
+    public System.Net.IPAddress Address { get { return default(System.Net.IPAddress); } set { } }
+    public override System.Net.Sockets.AddressFamily AddressFamily { get { return default(System.Net.Sockets.AddressFamily); } }
+    public int Port { get { return default(int); } set { } }
+    public override System.Net.EndPoint Create(System.Net.SocketAddress socketAddress) { return default(System.Net.EndPoint); }
+    public override bool Equals(object comparand) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override System.Net.SocketAddress Serialize() { return default(System.Net.SocketAddress); }
+    public override string ToString() { return default(string); }
+  }
+
+  public partial interface IWebProxy {
+    System.Net.ICredentials Credentials { get; set; }
+    System.Uri GetProxy(System.Uri destination);
+    bool IsBypassed(System.Uri host);
+  }
+
+  public partial class NetworkCredential : System.Net.ICredentials, System.Net.ICredentialsByHost {
+    public NetworkCredential() { }
+    public NetworkCredential(string userName, System.Security.SecureString password) { }
+    public NetworkCredential(string userName, System.Security.SecureString password, string domain) { }
+    public NetworkCredential(string userName, string password) { }
+    public NetworkCredential(string userName, string password, string domain) { }
+    public string Domain { get { return default(string); } set { } }
+    public string Password { get { return default(string); } set { } }
+    public System.Security.SecureString SecurePassword { get { return default(System.Security.SecureString); } set { } }
+    public string UserName { get { return default(string); } set { } }
+    public System.Net.NetworkCredential GetCredential(string host, int port, string authenticationType) { return default(System.Net.NetworkCredential); }
+    public System.Net.NetworkCredential GetCredential(System.Uri uri, string authType) { return default(System.Net.NetworkCredential); }
+  }
+
+  public partial class SocketAddress {
+    public SocketAddress(System.Net.Sockets.AddressFamily family) { }
+    public SocketAddress(System.Net.Sockets.AddressFamily family, int size) { }
+    public System.Net.Sockets.AddressFamily Family { get { return default(System.Net.Sockets.AddressFamily); } }
+    public byte this[int offset] { get { return default(byte); } set { } }
+    public int Size { get { return default(int); } }
+    public override bool Equals(object comparand) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+} // end of System.Net
+namespace System.Net.NetworkInformation {
+  public partial class IPAddressCollection : System.Collections.Generic.ICollection<System.Net.IPAddress>, System.Collections.Generic.IEnumerable<System.Net.IPAddress>, System.Collections.IEnumerable {
+    protected internal IPAddressCollection() { }
+    public virtual int Count { get { return default(int); } }
+    public virtual bool IsReadOnly { get { return default(bool); } }
+    public virtual System.Net.IPAddress this[int index] { get { return default(System.Net.IPAddress); } }
+    public virtual void Add(System.Net.IPAddress address) { }
+    public virtual void Clear() { }
+    public virtual bool Contains(System.Net.IPAddress address) { return default(bool); }
+    public virtual void CopyTo(System.Net.IPAddress[] array, int offset) { }
+    public virtual System.Collections.Generic.IEnumerator<System.Net.IPAddress> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Net.IPAddress>); }
+    public virtual bool Remove(System.Net.IPAddress address) { return default(bool); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+} // end of System.Net.NetworkInformation
+namespace System.Net.Security {
+  public enum AuthenticationLevel {
+    MutualAuthRequested = 1,
+    MutualAuthRequired = 2,
+    None = 0,
+  }
+
+  [System.FlagsAttribute]
+  public enum SslPolicyErrors {
+    None = 0,
+    RemoteCertificateChainErrors = 4,
+    RemoteCertificateNameMismatch = 2,
+    RemoteCertificateNotAvailable = 1,
+  }
+
+} // end of System.Net.Security
+namespace System.Net.Sockets {
+  public enum AddressFamily {
+    AppleTalk = 16,
+    Atm = 22,
+    Banyan = 21,
+    Ccitt = 10,
+    Chaos = 5,
+    Cluster = 24,
+    DataKit = 9,
+    DataLink = 13,
+    DecNet = 12,
+    Ecma = 8,
+    FireFox = 19,
+    HyperChannel = 15,
+    Ieee12844 = 25,
+    ImpLink = 3,
+    InterNetwork = 2,
+    InterNetworkV6 = 23,
+    Ipx = 6,
+    Irda = 26,
+    Iso = 7,
+    Lat = 14,
+    Max = 29,
+    NetBios = 17,
+    NetworkDesigners = 28,
+    NS = 6,
+    Osi = 7,
+    Pup = 4,
+    Sna = 11,
+    Unix = 1,
+    Unknown = -1,
+    Unspecified = 0,
+    VoiceView = 18,
+  }
+
+  public enum SocketError {
+    AccessDenied = 10013,
+    AddressAlreadyInUse = 10048,
+    AddressFamilyNotSupported = 10047,
+    AddressNotAvailable = 10049,
+    AlreadyInProgress = 10037,
+    ConnectionAborted = 10053,
+    ConnectionRefused = 10061,
+    ConnectionReset = 10054,
+    DestinationAddressRequired = 10039,
+    Disconnecting = 10101,
+    Fault = 10014,
+    HostDown = 10064,
+    HostNotFound = 11001,
+    HostUnreachable = 10065,
+    InProgress = 10036,
+    Interrupted = 10004,
+    InvalidArgument = 10022,
+    IOPending = 997,
+    IsConnected = 10056,
+    MessageSize = 10040,
+    NetworkDown = 10050,
+    NetworkReset = 10052,
+    NetworkUnreachable = 10051,
+    NoBufferSpaceAvailable = 10055,
+    NoData = 11004,
+    NoRecovery = 11003,
+    NotConnected = 10057,
+    NotInitialized = 10093,
+    NotSocket = 10038,
+    OperationAborted = 995,
+    OperationNotSupported = 10045,
+    ProcessLimit = 10067,
+    ProtocolFamilyNotSupported = 10046,
+    ProtocolNotSupported = 10043,
+    ProtocolOption = 10042,
+    ProtocolType = 10041,
+    Shutdown = 10058,
+    SocketError = -1,
+    SocketNotSupported = 10044,
+    Success = 0,
+    SystemNotReady = 10091,
+    TimedOut = 10060,
+    TooManyOpenSockets = 10024,
+    TryAgain = 11002,
+    TypeNotFound = 10109,
+    VersionNotSupported = 10092,
+    WouldBlock = 10035,
+  }
+
+  public partial class SocketException : System.ComponentModel.Win32Exception {
+    public SocketException() { }
+    public SocketException(int error) { }
+    protected SocketException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public override int ErrorCode { get { return default(int); } }
+    public override string Message { get { return default(string); } }
+    public System.Net.Sockets.SocketError SocketErrorCode { get { return default(System.Net.Sockets.SocketError); } }
+  }
+
+} // end of System.Net.Sockets
+namespace System.Security.Authentication {
+  public enum CipherAlgorithmType {
+    Aes = 26129,
+    Aes128 = 26126,
+    Aes192 = 26127,
+    Aes256 = 26128,
+    Des = 26113,
+    None = 0,
+    Null = 24576,
+    Rc2 = 26114,
+    Rc4 = 26625,
+    TripleDes = 26115,
+  }
+
+  public enum ExchangeAlgorithmType {
+    DiffieHellman = 43522,
+    None = 0,
+    RsaKeyX = 41984,
+    RsaSign = 9216,
+  }
+
+  public enum HashAlgorithmType {
+    Md5 = 32771,
+    None = 0,
+    Sha1 = 32772,
+  }
+
+  [System.FlagsAttribute]
+  public enum SslProtocols {
+    Default = 240,
+    None = 0,
+    Ssl2 = 12,
+    Ssl3 = 48,
+    Tls = 192,
+    Tls11 = 768,
+    Tls12 = 3072,
+  }
+
+} // end of System.Security.Authentication
+namespace System.Security.Authentication.ExtendedProtection {
+  public abstract partial class ChannelBinding : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid {
+    protected ChannelBinding() : base (default(bool)) { }
+    protected ChannelBinding(bool ownsHandle) : base (default(bool)) { }
+    public abstract int Size { get; }
+  }
+
+  public enum ChannelBindingKind {
+    Endpoint = 2,
+    Unique = 1,
+    Unknown = 0,
+  }
+
+} // end of System.Security.Authentication.ExtendedProtection

fxdac/fxdac/Data/Contracts/System.Net.Requests.cs

@@ -0,0 +1,246 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  public delegate System.Net.IPEndPoint BindIPEndPoint(System.Net.ServicePoint servicePoint, System.Net.IPEndPoint remoteEndPoint, int retryCount);
+
+  public delegate void HttpContinueDelegate(int StatusCode, System.Net.WebHeaderCollection httpHeaders);
+
+  public partial class HttpWebRequest : System.Net.WebRequest, System.Runtime.Serialization.ISerializable {
+    [System.ObsoleteAttribute("Serialization is obsoleted for this type", false)]
+    protected HttpWebRequest(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public HttpWebRequest(System.Uri uri) { }
+    public string Accept { get { return default(string); } set { } }
+    public System.Uri Address { get { return default(System.Uri); } }
+    public bool AllowAutoRedirect { get { return default(bool); } set { } }
+    public virtual bool AllowReadStreamBuffering { get { return default(bool); } set { } }
+    public bool AllowWriteStreamBuffering { get { return default(bool); } set { } }
+    public System.Net.DecompressionMethods AutomaticDecompression { get { return default(System.Net.DecompressionMethods); } set { } }
+    public System.Security.Cryptography.X509Certificates.X509CertificateCollection ClientCertificates { get { return default(System.Security.Cryptography.X509Certificates.X509CertificateCollection); } set { } }
+    public string Connection { get { return default(string); } set { } }
+    public override string ConnectionGroupName { get { return default(string); } set { } }
+    public override long ContentLength { get { return default(long); } set { } }
+    public override string ContentType { get { return default(string); } set { } }
+    public System.Net.HttpContinueDelegate ContinueDelegate { get { return default(System.Net.HttpContinueDelegate); } set { } }
+    public int ContinueTimeout { get { return default(int); } set { } }
+    public virtual System.Net.CookieContainer CookieContainer { get { return default(System.Net.CookieContainer); } set { } }
+    public override System.Net.ICredentials Credentials { get { return default(System.Net.ICredentials); } set { } }
+    public System.DateTime Date { get { return default(System.DateTime); } set { } }
+    public static int DefaultMaximumErrorResponseLength { get { return default(int); } set { } }
+    public static int DefaultMaximumResponseHeadersLength { get { return default(int); } set { } }
+    public string Expect { get { return default(string); } set { } }
+    public virtual bool HaveResponse { get { return default(bool); } }
+    public override System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } set { } }
+    public string Host { get { return default(string); } set { } }
+    public System.DateTime IfModifiedSince { get { return default(System.DateTime); } set { } }
+    public bool KeepAlive { get { return default(bool); } set { } }
+    public int MaximumAutomaticRedirections { get { return default(int); } set { } }
+    public int MaximumResponseHeadersLength { get { return default(int); } set { } }
+    public string MediaType { get { return default(string); } set { } }
+    public override string Method { get { return default(string); } set { } }
+    public bool Pipelined { get { return default(bool); } set { } }
+    public override bool PreAuthenticate { get { return default(bool); } set { } }
+    public System.Version ProtocolVersion { get { return default(System.Version); } set { } }
+    public override System.Net.IWebProxy Proxy { get { return default(System.Net.IWebProxy); } set { } }
+    public int ReadWriteTimeout { get { return default(int); } set { } }
+    public string Referer { get { return default(string); } set { } }
+    public override System.Uri RequestUri { get { return default(System.Uri); } }
+    public bool SendChunked { get { return default(bool); } set { } }
+    public System.Net.ServicePoint ServicePoint { get { return default(System.Net.ServicePoint); } }
+    public virtual bool SupportsCookieContainer { get { return default(bool); } }
+    public override int Timeout { get { return default(int); } set { } }
+    public string TransferEncoding { get { return default(string); } set { } }
+    public bool UnsafeAuthenticatedConnectionSharing { get { return default(bool); } set { } }
+    public override bool UseDefaultCredentials { get { return default(bool); } set { } }
+    public string UserAgent { get { return default(string); } set { } }
+    public override void Abort() { }
+    public void AddRange(int range) { }
+    public void AddRange(int from, int to) { }
+    public void AddRange(long range) { }
+    public void AddRange(long from, long to) { }
+    public void AddRange(string rangeSpecifier, int range) { }
+    public void AddRange(string rangeSpecifier, int from, int to) { }
+    public void AddRange(string rangeSpecifier, long range) { }
+    public void AddRange(string rangeSpecifier, long from, long to) { }
+    public override System.IAsyncResult BeginGetRequestStream(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginGetResponse(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public override System.IO.Stream EndGetRequestStream(System.IAsyncResult asyncResult) { return default(System.IO.Stream); }
+    public System.IO.Stream EndGetRequestStream(System.IAsyncResult asyncResult, out System.Net.TransportContext transportContext) { transportContext = default(System.Net.TransportContext); return default(System.IO.Stream); }
+    public override System.Net.WebResponse EndGetResponse(System.IAsyncResult asyncResult) { return default(System.Net.WebResponse); }
+    protected override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override System.IO.Stream GetRequestStream() { return default(System.IO.Stream); }
+    public override System.Net.WebResponse GetResponse() { return default(System.Net.WebResponse); }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  public partial class HttpWebResponse : System.Net.WebResponse, System.IDisposable, System.Runtime.Serialization.ISerializable {
+    [System.ObsoleteAttribute("Serialization is obsoleted for this type", false)]
+    protected HttpWebResponse(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public string CharacterSet { get { return default(string); } }
+    public string ContentEncoding { get { return default(string); } }
+    public override long ContentLength { get { return default(long); } }
+    public override string ContentType { get { return default(string); } }
+    public virtual System.Net.CookieCollection Cookies { get { return default(System.Net.CookieCollection); } set { } }
+    public override System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } }
+    public override bool IsMutuallyAuthenticated { get { return default(bool); } }
+    public System.DateTime LastModified { get { return default(System.DateTime); } }
+    public virtual string Method { get { return default(string); } }
+    public System.Version ProtocolVersion { get { return default(System.Version); } }
+    public override System.Uri ResponseUri { get { return default(System.Uri); } }
+    public string Server { get { return default(string); } }
+    public virtual System.Net.HttpStatusCode StatusCode { get { return default(System.Net.HttpStatusCode); } }
+    public virtual string StatusDescription { get { return default(string); } }
+    public override void Close() { }
+    protected override void Dispose(bool disposing) { }
+    protected override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public string GetResponseHeader(string headerName) { return default(string); }
+    public override System.IO.Stream GetResponseStream() { return default(System.IO.Stream); }
+    void System.IDisposable.Dispose() { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  public partial interface IWebRequestCreate {
+    System.Net.WebRequest Create(System.Uri uri);
+  }
+
+  public partial class ProtocolViolationException : System.InvalidOperationException, System.Runtime.Serialization.ISerializable {
+    public ProtocolViolationException() { }
+    protected ProtocolViolationException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public ProtocolViolationException(string message) { }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+  }
+
+  public partial class ServicePoint {
+    internal ServicePoint() { }
+    public System.Uri Address { get { return default(System.Uri); } }
+    public System.Net.BindIPEndPoint BindIPEndPointDelegate { get { return default(System.Net.BindIPEndPoint); } set { } }
+    public System.Security.Cryptography.X509Certificates.X509Certificate Certificate { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } }
+    public System.Security.Cryptography.X509Certificates.X509Certificate ClientCertificate { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } }
+    public int ConnectionLeaseTimeout { get { return default(int); } set { } }
+    public int ConnectionLimit { get { return default(int); } set { } }
+    public string ConnectionName { get { return default(string); } }
+    public int CurrentConnections { get { return default(int); } }
+    public bool Expect100Continue { get { return default(bool); } set { } }
+    public System.DateTime IdleSince { get { return default(System.DateTime); } }
+    public int MaxIdleTime { get { return default(int); } set { } }
+    public virtual System.Version ProtocolVersion { get { return default(System.Version); } }
+    public int ReceiveBufferSize { get { return default(int); } set { } }
+    public bool SupportsPipelining { get { return default(bool); } }
+    public bool UseNagleAlgorithm { get { return default(bool); } set { } }
+    public bool CloseConnectionGroup(string connectionGroupName) { return default(bool); }
+    public void SetTcpKeepAlive(bool enabled, int keepAliveTime, int keepAliveInterval) { }
+  }
+
+  public partial class WebException : System.InvalidOperationException, System.Runtime.Serialization.ISerializable {
+    public WebException() { }
+    protected WebException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public WebException(string message) { }
+    public WebException(string message, System.Exception innerException) { }
+    public WebException(string message, System.Exception innerException, System.Net.WebExceptionStatus status, System.Net.WebResponse response) { }
+    public WebException(string message, System.Net.WebExceptionStatus status) { }
+    public System.Net.WebResponse Response { get { return default(System.Net.WebResponse); } }
+    public System.Net.WebExceptionStatus Status { get { return default(System.Net.WebExceptionStatus); } }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+  }
+
+  public enum WebExceptionStatus {
+    CacheEntryNotFound = 18,
+    ConnectFailure = 2,
+    ConnectionClosed = 8,
+    KeepAliveFailure = 12,
+    MessageLengthLimitExceeded = 17,
+    NameResolutionFailure = 1,
+    Pending = 13,
+    PipelineFailure = 5,
+    ProtocolError = 7,
+    ProxyNameResolutionFailure = 15,
+    ReceiveFailure = 3,
+    RequestCanceled = 6,
+    RequestProhibitedByCachePolicy = 19,
+    RequestProhibitedByProxy = 20,
+    SecureChannelFailure = 10,
+    SendFailure = 4,
+    ServerProtocolViolation = 11,
+    Success = 0,
+    Timeout = 14,
+    TrustFailure = 9,
+    UnknownError = 16,
+  }
+
+  public abstract partial class WebRequest :System.Runtime.Serialization.ISerializable {
+    protected WebRequest() { }
+    protected WebRequest(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public System.Net.Security.AuthenticationLevel AuthenticationLevel { get { return default(System.Net.Security.AuthenticationLevel); } set { } }
+    public virtual System.Net.Cache.RequestCachePolicy CachePolicy { get { return default(System.Net.Cache.RequestCachePolicy); } set { } }
+    public virtual string ConnectionGroupName { get { return default(string); } set { } }
+    public virtual long ContentLength { get { return default(long); } set { } }
+    public virtual string ContentType { get { return default(string); } set { } }
+    public virtual System.Net.ICredentials Credentials { get { return default(System.Net.ICredentials); } set { } }
+    public static System.Net.Cache.RequestCachePolicy DefaultCachePolicy { get { return default(System.Net.Cache.RequestCachePolicy); } set { } }
+    public static System.Net.IWebProxy DefaultWebProxy { get { return default(System.Net.IWebProxy); } set { } }
+    public virtual System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } set { } }
+    public System.Security.Principal.TokenImpersonationLevel ImpersonationLevel { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Security.Principal.TokenImpersonationLevel); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public virtual string Method { get { return default(string); } set { } }
+    public virtual bool PreAuthenticate { get { return default(bool); } set { } }
+    public virtual System.Net.IWebProxy Proxy { get { return default(System.Net.IWebProxy); } set { } }
+    public virtual System.Uri RequestUri { get { return default(System.Uri); } }
+    public virtual int Timeout { get { return default(int); } set { } }
+    public virtual bool UseDefaultCredentials { get { return default(bool); } set { } }
+    public virtual void Abort() { }
+    public virtual System.IAsyncResult BeginGetRequestStream(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public virtual System.IAsyncResult BeginGetResponse(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public static System.Net.WebRequest Create(string requestUriString) { return default(System.Net.WebRequest); }
+    public static System.Net.WebRequest Create(System.Uri requestUri) { return default(System.Net.WebRequest); }
+    public static System.Net.WebRequest CreateDefault(System.Uri requestUri) { return default(System.Net.WebRequest); }
+    public static System.Net.HttpWebRequest CreateHttp(string requestUriString) { return default(System.Net.HttpWebRequest); }
+    public static System.Net.HttpWebRequest CreateHttp(System.Uri requestUri) { return default(System.Net.HttpWebRequest); }
+    public virtual System.IO.Stream EndGetRequestStream(System.IAsyncResult asyncResult) { return default(System.IO.Stream); }
+    public virtual System.Net.WebResponse EndGetResponse(System.IAsyncResult asyncResult) { return default(System.Net.WebResponse); }
+    protected virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public virtual System.IO.Stream GetRequestStream() { return default(System.IO.Stream); }
+    public virtual System.Threading.Tasks.Task<System.IO.Stream> GetRequestStreamAsync() { return default(System.Threading.Tasks.Task<System.IO.Stream>); }
+    public virtual System.Net.WebResponse GetResponse() { return default(System.Net.WebResponse); }
+    public virtual System.Threading.Tasks.Task<System.Net.WebResponse> GetResponseAsync() { return default(System.Threading.Tasks.Task<System.Net.WebResponse>); }
+    public static System.Net.IWebProxy GetSystemWebProxy() { return default(System.Net.IWebProxy); }
+    public static bool RegisterPrefix(string prefix, System.Net.IWebRequestCreate creator) { return default(bool); }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  public abstract partial class WebResponse :System.IDisposable, System.Runtime.Serialization.ISerializable {
+    protected WebResponse() { }
+    protected WebResponse(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public virtual long ContentLength { get { return default(long); } set { } }
+    public virtual string ContentType { get { return default(string); } set { } }
+    public virtual System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } }
+    public virtual bool IsFromCache { get { return default(bool); } }
+    public virtual bool IsMutuallyAuthenticated { get { return default(bool); } }
+    public virtual System.Uri ResponseUri { get { return default(System.Uri); } }
+    public virtual bool SupportsHeaders { get { return default(bool); } }
+    public virtual void Close() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    protected virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public virtual System.IO.Stream GetResponseStream() { return default(System.IO.Stream); }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+} // end of System.Net
+namespace System.Net.Cache {
+  public enum RequestCacheLevel {
+    BypassCache = 1,
+    CacheIfAvailable = 3,
+    CacheOnly = 2,
+    Default = 0,
+    NoCacheNoStore = 6,
+    Reload = 5,
+    Revalidate = 4,
+  }
+
+  public partial class RequestCachePolicy {
+    public RequestCachePolicy() { }
+    public RequestCachePolicy(System.Net.Cache.RequestCacheLevel level) { }
+    public System.Net.Cache.RequestCacheLevel Level { get { return default(System.Net.Cache.RequestCacheLevel); } }
+    public override string ToString() { return default(string); }
+  }
+
+} // end of System.Net.Cache

fxdac/fxdac/Data/Contracts/System.Net.Security.Permissions.cs

@@ -0,0 +1,31 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  public sealed partial class WebPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public WebPermission() { }
+    public WebPermission(System.Net.NetworkAccess access, string uriString) { }
+    public WebPermission(System.Net.NetworkAccess access, System.Text.RegularExpressions.Regex uriRegex) { }
+    public WebPermission(System.Security.Permissions.PermissionState state) { }
+    public System.Collections.IEnumerator AcceptList { get { return default(System.Collections.IEnumerator); } }
+    public System.Collections.IEnumerator ConnectList { get { return default(System.Collections.IEnumerator); } }
+    public void AddPermission(System.Net.NetworkAccess access, string uriString) { }
+    public void AddPermission(System.Net.NetworkAccess access, System.Text.RegularExpressions.Regex uriRegex) { }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement securityElement) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  public sealed partial class WebPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public WebPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public string Accept { get { return default(string); } set { } }
+    public string AcceptPattern { get { return default(string); } set { } }
+    public string Connect { get { return default(string); } set { } }
+    public string ConnectPattern { get { return default(string); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+} // end of System.Net

fxdac/fxdac/Data/Contracts/System.Net.Security.cs

@@ -0,0 +1,179 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  public abstract partial class TransportContext {
+    protected TransportContext() { }
+    public abstract System.Security.Authentication.ExtendedProtection.ChannelBinding GetChannelBinding(System.Security.Authentication.ExtendedProtection.ChannelBindingKind kind);
+  }
+
+} // end of System.Net
+namespace System.Net.Security {
+  public abstract partial class AuthenticatedStream : System.IO.Stream {
+    protected AuthenticatedStream(System.IO.Stream innerStream, bool leaveInnerStreamOpen) { }
+    protected System.IO.Stream InnerStream { get { return default(System.IO.Stream); } }
+    public abstract bool IsAuthenticated { get; }
+    public abstract bool IsEncrypted { get; }
+    public abstract bool IsMutuallyAuthenticated { get; }
+    public abstract bool IsServer { get; }
+    public abstract bool IsSigned { get; }
+    public bool LeaveInnerStreamOpen { get { return default(bool); } }
+    protected override void Dispose(bool disposing) { }
+  }
+
+  public delegate System.Security.Cryptography.X509Certificates.X509Certificate LocalCertificateSelectionCallback(object sender, string targetHost, System.Security.Cryptography.X509Certificates.X509CertificateCollection localCertificates, System.Security.Cryptography.X509Certificates.X509Certificate remoteCertificate, string[] acceptableIssuers);
+
+  public partial class NegotiateStream : System.Net.Security.AuthenticatedStream {
+    public NegotiateStream(System.IO.Stream innerStream) : base (default(System.IO.Stream), default(bool)) { }
+    public NegotiateStream(System.IO.Stream innerStream, bool leaveInnerStreamOpen) : base (default(System.IO.Stream), default(bool)) { }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanTimeout { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    public virtual System.Security.Principal.TokenImpersonationLevel ImpersonationLevel { get { return default(System.Security.Principal.TokenImpersonationLevel); } }
+    public override bool IsAuthenticated { get { return default(bool); } }
+    public override bool IsEncrypted { get { return default(bool); } }
+    public override bool IsMutuallyAuthenticated { get { return default(bool); } }
+    public override bool IsServer { get { return default(bool); } }
+    public override bool IsSigned { get { return default(bool); } }
+    public override long Length { get { return default(long); } }
+    public override long Position { get { return default(long); } set { } }
+    public override int ReadTimeout { get { return default(int); } set { } }
+    public virtual System.Security.Principal.IIdentity RemoteIdentity { get { return default(System.Security.Principal.IIdentity); } }
+    public override int WriteTimeout { get { return default(int); } set { } }
+    public virtual void AuthenticateAsClient() { }
+    public virtual void AuthenticateAsClient(System.Net.NetworkCredential credential, string targetName) { }
+    public virtual void AuthenticateAsClient(System.Net.NetworkCredential credential, string targetName, System.Net.Security.ProtectionLevel requiredProtectionLevel, System.Security.Principal.TokenImpersonationLevel allowedImpersonationLevel) { }
+    public virtual void AuthenticateAsServer() { }
+    public virtual void AuthenticateAsServer(System.Net.NetworkCredential credential, System.Net.Security.ProtectionLevel requiredProtectionLevel, System.Security.Principal.TokenImpersonationLevel requiredImpersonationLevel) { }
+    public virtual System.IAsyncResult BeginAuthenticateAsClient(System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public virtual System.IAsyncResult BeginAuthenticateAsClient(System.Net.NetworkCredential credential, string targetName, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public virtual System.IAsyncResult BeginAuthenticateAsClient(System.Net.NetworkCredential credential, string targetName, System.Net.Security.ProtectionLevel requiredProtectionLevel, System.Security.Principal.TokenImpersonationLevel allowedImpersonationLevel, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public virtual System.IAsyncResult BeginAuthenticateAsServer(System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public virtual System.IAsyncResult BeginAuthenticateAsServer(System.Net.NetworkCredential credential, System.Net.Security.ProtectionLevel requiredProtectionLevel, System.Security.Principal.TokenImpersonationLevel requiredImpersonationLevel, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginRead(byte[] buffer, int offset, int count, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginWrite(byte[] buffer, int offset, int count, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    protected override void Dispose(bool disposing) { }
+    public virtual void EndAuthenticateAsClient(System.IAsyncResult asyncResult) { }
+    public virtual void EndAuthenticateAsServer(System.IAsyncResult asyncResult) { }
+    public override int EndRead(System.IAsyncResult asyncResult) { return default(int); }
+    public override void EndWrite(System.IAsyncResult asyncResult) { }
+    public override void Flush() { }
+    public override int Read(byte[] buffer, int offset, int count) { return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin origin) { return default(long); }
+    public override void SetLength(long value) { }
+    public override void Write(byte[] buffer, int offset, int count) { }
+  }
+
+  public enum ProtectionLevel {
+    EncryptAndSign = 2,
+    None = 0,
+    Sign = 1,
+  }
+
+  public delegate bool RemoteCertificateValidationCallback(object sender, System.Security.Cryptography.X509Certificates.X509Certificate certificate, System.Security.Cryptography.X509Certificates.X509Chain chain, System.Net.Security.SslPolicyErrors sslPolicyErrors);
+
+  public partial class SslStream : System.Net.Security.AuthenticatedStream {
+    public SslStream(System.IO.Stream innerStream) : base (default(System.IO.Stream), default(bool)) { }
+    public SslStream(System.IO.Stream innerStream, bool leaveInnerStreamOpen) : base (default(System.IO.Stream), default(bool)) { }
+    public SslStream(System.IO.Stream innerStream, bool leaveInnerStreamOpen, System.Net.Security.RemoteCertificateValidationCallback userCertificateValidationCallback) : base (default(System.IO.Stream), default(bool)) { }
+    public SslStream(System.IO.Stream innerStream, bool leaveInnerStreamOpen, System.Net.Security.RemoteCertificateValidationCallback userCertificateValidationCallback, System.Net.Security.LocalCertificateSelectionCallback userCertificateSelectionCallback) : base (default(System.IO.Stream), default(bool)) { }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanTimeout { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    public virtual bool CheckCertRevocationStatus { get { return default(bool); } }
+    public virtual System.Security.Authentication.CipherAlgorithmType CipherAlgorithm { get { return default(System.Security.Authentication.CipherAlgorithmType); } }
+    public virtual int CipherStrength { get { return default(int); } }
+    public virtual System.Security.Authentication.HashAlgorithmType HashAlgorithm { get { return default(System.Security.Authentication.HashAlgorithmType); } }
+    public virtual int HashStrength { get { return default(int); } }
+    public override bool IsAuthenticated { get { return default(bool); } }
+    public override bool IsEncrypted { get { return default(bool); } }
+    public override bool IsMutuallyAuthenticated { get { return default(bool); } }
+    public override bool IsServer { get { return default(bool); } }
+    public override bool IsSigned { get { return default(bool); } }
+    public virtual System.Security.Authentication.ExchangeAlgorithmType KeyExchangeAlgorithm { get { return default(System.Security.Authentication.ExchangeAlgorithmType); } }
+    public virtual int KeyExchangeStrength { get { return default(int); } }
+    public override long Length { get { return default(long); } }
+    public virtual System.Security.Cryptography.X509Certificates.X509Certificate LocalCertificate { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } }
+    public override long Position { get { return default(long); } set { } }
+    public override int ReadTimeout { get { return default(int); } set { } }
+    public virtual System.Security.Cryptography.X509Certificates.X509Certificate RemoteCertificate { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } }
+    public virtual System.Security.Authentication.SslProtocols SslProtocol { get { return default(System.Security.Authentication.SslProtocols); } }
+    public override int WriteTimeout { get { return default(int); } set { } }
+    public virtual void AuthenticateAsClient(string targetHost) { }
+    public virtual void AuthenticateAsClient(string targetHost, System.Security.Cryptography.X509Certificates.X509CertificateCollection clientCertificates, System.Security.Authentication.SslProtocols enabledSslProtocols, bool checkCertificateRevocation) { }
+    public virtual System.Threading.Tasks.Task AuthenticateAsClientAsync(string targetHost) { return default(System.Threading.Tasks.Task); }
+    public virtual System.Threading.Tasks.Task AuthenticateAsClientAsync(string targetHost, System.Security.Cryptography.X509Certificates.X509CertificateCollection clientCertificates, System.Security.Authentication.SslProtocols enabledSslProtocols, bool checkCertificateRevocation) { return default(System.Threading.Tasks.Task); }
+    public virtual void AuthenticateAsServer(System.Security.Cryptography.X509Certificates.X509Certificate serverCertificate) { }
+    public virtual void AuthenticateAsServer(System.Security.Cryptography.X509Certificates.X509Certificate serverCertificate, bool clientCertificateRequired, System.Security.Authentication.SslProtocols enabledSslProtocols, bool checkCertificateRevocation) { }
+    public virtual System.Threading.Tasks.Task AuthenticateAsServerAsync(System.Security.Cryptography.X509Certificates.X509Certificate serverCertificate) { return default(System.Threading.Tasks.Task); }
+    public virtual System.Threading.Tasks.Task AuthenticateAsServerAsync(System.Security.Cryptography.X509Certificates.X509Certificate serverCertificate, bool clientCertificateRequired, System.Security.Authentication.SslProtocols enabledSslProtocols, bool checkCertificateRevocation) { return default(System.Threading.Tasks.Task); }
+    public virtual System.IAsyncResult BeginAuthenticateAsClient(string targetHost, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public virtual System.IAsyncResult BeginAuthenticateAsClient(string targetHost, System.Security.Cryptography.X509Certificates.X509CertificateCollection clientCertificates, System.Security.Authentication.SslProtocols enabledSslProtocols, bool checkCertificateRevocation, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public virtual System.IAsyncResult BeginAuthenticateAsServer(System.Security.Cryptography.X509Certificates.X509Certificate serverCertificate, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public virtual System.IAsyncResult BeginAuthenticateAsServer(System.Security.Cryptography.X509Certificates.X509Certificate serverCertificate, bool clientCertificateRequired, System.Security.Authentication.SslProtocols enabledSslProtocols, bool checkCertificateRevocation, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginRead(byte[] buffer, int offset, int count, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginWrite(byte[] buffer, int offset, int count, System.AsyncCallback asyncCallback, object asyncState) { return default(System.IAsyncResult); }
+    protected override void Dispose(bool disposing) { }
+    public virtual void EndAuthenticateAsClient(System.IAsyncResult asyncResult) { }
+    public virtual void EndAuthenticateAsServer(System.IAsyncResult asyncResult) { }
+    public override int EndRead(System.IAsyncResult asyncResult) { return default(int); }
+    public override void EndWrite(System.IAsyncResult asyncResult) { }
+    public override void Flush() { }
+    public override int Read(byte[] buffer, int offset, int count) { return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin origin) { return default(long); }
+    public override void SetLength(long value) { }
+    public void Write(byte[] buffer) { }
+    public override void Write(byte[] buffer, int offset, int count) { }
+  }
+
+} // end of System.Net.Security
+namespace System.Security.Authentication {
+  public partial class AuthenticationException : System.SystemException {
+    public AuthenticationException() { }
+    protected AuthenticationException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public AuthenticationException(string message) { }
+    public AuthenticationException(string message, System.Exception innerException) { }
+  }
+
+  public partial class InvalidCredentialException : System.Security.Authentication.AuthenticationException {
+    public InvalidCredentialException() { }
+    protected InvalidCredentialException(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public InvalidCredentialException(string message) { }
+    public InvalidCredentialException(string message, System.Exception innerException) { }
+  }
+
+} // end of System.Security.Authentication
+namespace System.Security.Authentication.ExtendedProtection {
+  public partial class ExtendedProtectionPolicy : System.Runtime.Serialization.ISerializable {
+    protected ExtendedProtectionPolicy(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public ExtendedProtectionPolicy(System.Security.Authentication.ExtendedProtection.PolicyEnforcement policyEnforcement) { }
+    public ExtendedProtectionPolicy(System.Security.Authentication.ExtendedProtection.PolicyEnforcement policyEnforcement, System.Security.Authentication.ExtendedProtection.ChannelBinding customChannelBinding) { }
+    public ExtendedProtectionPolicy(System.Security.Authentication.ExtendedProtection.PolicyEnforcement policyEnforcement, System.Security.Authentication.ExtendedProtection.ProtectionScenario protectionScenario, System.Collections.ICollection customServiceNames) { }
+    public ExtendedProtectionPolicy(System.Security.Authentication.ExtendedProtection.PolicyEnforcement policyEnforcement, System.Security.Authentication.ExtendedProtection.ProtectionScenario protectionScenario, System.Security.Authentication.ExtendedProtection.ServiceNameCollection customServiceNames) { }
+    public System.Security.Authentication.ExtendedProtection.ChannelBinding CustomChannelBinding { get { return default(System.Security.Authentication.ExtendedProtection.ChannelBinding); } }
+    public System.Security.Authentication.ExtendedProtection.ServiceNameCollection CustomServiceNames { get { return default(System.Security.Authentication.ExtendedProtection.ServiceNameCollection); } }
+    public static bool OSSupportsExtendedProtection { get { return default(bool); } }
+    public System.Security.Authentication.ExtendedProtection.PolicyEnforcement PolicyEnforcement { get { return default(System.Security.Authentication.ExtendedProtection.PolicyEnforcement); } }
+    public System.Security.Authentication.ExtendedProtection.ProtectionScenario ProtectionScenario { get { return default(System.Security.Authentication.ExtendedProtection.ProtectionScenario); } }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public override string ToString() { return default(string); }
+  }
+
+  public enum PolicyEnforcement {
+    Always = 2,
+    Never = 0,
+    WhenSupported = 1,
+  }
+
+  public enum ProtectionScenario {
+    TransportSelected = 0,
+    TrustedProxy = 1,
+  }
+
+  public partial class ServiceNameCollection : System.Collections.ReadOnlyCollectionBase {
+    public ServiceNameCollection(System.Collections.ICollection items) { }
+    public System.Security.Authentication.ExtendedProtection.ServiceNameCollection Merge(System.Collections.IEnumerable serviceNames) { return default(System.Security.Authentication.ExtendedProtection.ServiceNameCollection); }
+    public System.Security.Authentication.ExtendedProtection.ServiceNameCollection Merge(string serviceName) { return default(System.Security.Authentication.ExtendedProtection.ServiceNameCollection); }
+  }
+
+} // end of System.Security.Authentication.ExtendedProtection

fxdac/fxdac/Data/Contracts/System.Net.Sockets.cs

@@ -0,0 +1,581 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net.Sockets {
+  public enum IOControlCode : long {
+    AbsorbRouterAlert = (long)2550136837,
+    AddMulticastGroupOnInterface = (long)2550136842,
+    AddressListChange = (long)671088663,
+    AddressListQuery = (long)1207959574,
+    AddressListSort = (long)3355443225,
+    AssociateHandle = (long)2281701377,
+    AsyncIO = (long)2147772029,
+    BindToInterface = (long)2550136840,
+    DataToRead = (long)1074030207,
+    DeleteMulticastGroupFromInterface = (long)2550136843,
+    EnableCircularQueuing = (long)671088642,
+    Flush = (long)671088644,
+    GetBroadcastAddress = (long)1207959557,
+    GetExtensionFunctionPointer = (long)3355443206,
+    GetGroupQos = (long)3355443208,
+    GetQos = (long)3355443207,
+    KeepAliveValues = (long)2550136836,
+    LimitBroadcasts = (long)2550136839,
+    MulticastInterface = (long)2550136841,
+    MulticastScope = (long)2281701386,
+    MultipointLoopback = (long)2281701385,
+    NamespaceChange = (long)2281701401,
+    NonBlockingIO = (long)2147772030,
+    OobDataRead = (long)1074033415,
+    QueryTargetPnpHandle = (long)1207959576,
+    ReceiveAll = (long)2550136833,
+    ReceiveAllIgmpMulticast = (long)2550136835,
+    ReceiveAllMulticast = (long)2550136834,
+    RoutingInterfaceChange = (long)2281701397,
+    RoutingInterfaceQuery = (long)3355443220,
+    SetGroupQos = (long)2281701388,
+    SetQos = (long)2281701387,
+    TranslateHandle = (long)3355443213,
+    UnicastInterface = (long)2550136838,
+  }
+
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct IPPacketInformation {
+    public System.Net.IPAddress Address { get { return default(System.Net.IPAddress); } }
+    public int Interface { get { return default(int); } }
+    public override bool Equals(object comparand) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public static bool operator ==(System.Net.Sockets.IPPacketInformation p1, System.Net.Sockets.IPPacketInformation p2) { return default(bool); }
+    public static bool operator !=(System.Net.Sockets.IPPacketInformation p1, System.Net.Sockets.IPPacketInformation p2) { return default(bool); }
+  }
+
+  public partial class IPv6MulticastOption {
+    public IPv6MulticastOption(System.Net.IPAddress group) { }
+    public IPv6MulticastOption(System.Net.IPAddress group, long ifindex) { }
+    public System.Net.IPAddress Group { get { return default(System.Net.IPAddress); } set { } }
+    public long InterfaceIndex { get { return default(long); } set { } }
+  }
+
+  public partial class LingerOption {
+    public LingerOption(bool enable, int seconds) { }
+    public bool Enabled { get { return default(bool); } set { } }
+    public int LingerTime { get { return default(int); } set { } }
+  }
+
+  public partial class MulticastOption {
+    public MulticastOption(System.Net.IPAddress group) { }
+    public MulticastOption(System.Net.IPAddress group, int interfaceIndex) { }
+    public MulticastOption(System.Net.IPAddress group, System.Net.IPAddress mcint) { }
+    public System.Net.IPAddress Group { get { return default(System.Net.IPAddress); } set { } }
+    public int InterfaceIndex { get { return default(int); } set { } }
+    public System.Net.IPAddress LocalAddress { get { return default(System.Net.IPAddress); } set { } }
+  }
+
+  public partial class NetworkStream : System.IO.Stream, System.IDisposable {
+    public NetworkStream(System.Net.Sockets.Socket socket) { }
+    public NetworkStream(System.Net.Sockets.Socket socket, bool ownsSocket) { }
+    public NetworkStream(System.Net.Sockets.Socket socket, System.IO.FileAccess access) { }
+    public NetworkStream(System.Net.Sockets.Socket socket, System.IO.FileAccess access, bool ownsSocket) { }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanTimeout { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    public virtual bool DataAvailable { get { return default(bool); } }
+    public override long Length { get { return default(long); } }
+    public override long Position { get { return default(long); } set { } }
+    protected bool Readable { get { return default(bool); } set { } }
+    public override int ReadTimeout { get { return default(int); } set { } }
+    protected System.Net.Sockets.Socket Socket { get { return default(System.Net.Sockets.Socket); } }
+    protected bool Writeable { get { return default(bool); } set { } }
+    public override int WriteTimeout { get { return default(int); } set { } }
+    public override System.IAsyncResult BeginRead(byte[] buffer, int offset, int size, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginWrite(byte[] buffer, int offset, int size, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public void Close(int timeout) { }
+    protected override void Dispose(bool disposing) { }
+    public override int EndRead(System.IAsyncResult ar) { return default(int); }
+    public override void EndWrite(System.IAsyncResult ar) { }
+    ~NetworkStream() { }
+    public override void Flush() { }
+    public override int Read(byte[] buffer, int offset, int size) { buffer = default(byte[]); return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin origin) { return default(long); }
+    public override void SetLength(long value) { }
+    public override void Write(byte[] buffer, int offset, int size) { }
+  }
+
+  public enum ProtocolFamily {
+    AppleTalk = 16,
+    Atm = 22,
+    Banyan = 21,
+    Ccitt = 10,
+    Chaos = 5,
+    Cluster = 24,
+    DataKit = 9,
+    DataLink = 13,
+    DecNet = 12,
+    Ecma = 8,
+    FireFox = 19,
+    HyperChannel = 15,
+    Ieee12844 = 25,
+    ImpLink = 3,
+    InterNetwork = 2,
+    InterNetworkV6 = 23,
+    Ipx = 6,
+    Irda = 26,
+    Iso = 7,
+    Lat = 14,
+    Max = 29,
+    NetBios = 17,
+    NetworkDesigners = 28,
+    NS = 6,
+    Osi = 7,
+    Pup = 4,
+    Sna = 11,
+    Unix = 1,
+    Unknown = -1,
+    Unspecified = 0,
+    VoiceView = 18,
+  }
+
+  public enum ProtocolType {
+    Ggp = 3,
+    Icmp = 1,
+    IcmpV6 = 58,
+    Idp = 22,
+    Igmp = 2,
+    IP = 0,
+    IPSecAuthenticationHeader = 51,
+    IPSecEncapsulatingSecurityPayload = 50,
+    IPv4 = 4,
+    IPv6 = 41,
+    IPv6DestinationOptions = 60,
+    IPv6FragmentHeader = 44,
+    IPv6HopByHopOptions = 0,
+    IPv6NoNextHeader = 59,
+    IPv6RoutingHeader = 43,
+    Ipx = 1000,
+    ND = 77,
+    Pup = 12,
+    Raw = 255,
+    Spx = 1256,
+    SpxII = 1257,
+    Tcp = 6,
+    Udp = 17,
+    Unknown = -1,
+    Unspecified = 0,
+  }
+
+  public enum SelectMode {
+    SelectError = 2,
+    SelectRead = 0,
+    SelectWrite = 1,
+  }
+
+  public partial class SendPacketsElement {
+    public SendPacketsElement(byte[] buffer) { }
+    public SendPacketsElement(byte[] buffer, int offset, int count) { }
+    public SendPacketsElement(byte[] buffer, int offset, int count, bool endOfPacket) { }
+    public SendPacketsElement(string filepath) { }
+    public SendPacketsElement(string filepath, int offset, int count) { }
+    public SendPacketsElement(string filepath, int offset, int count, bool endOfPacket) { }
+    public byte[] Buffer { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(byte[]); } }
+    public int Count { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(int); } }
+    public bool EndOfPacket { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } }
+    public string FilePath { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(string); } }
+    public int Offset { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(int); } }
+  }
+
+  public partial class Socket : System.IDisposable {
+    public Socket(System.Net.Sockets.AddressFamily addressFamily, System.Net.Sockets.SocketType socketType, System.Net.Sockets.ProtocolType protocolType) { }
+    public Socket(System.Net.Sockets.SocketType socketType, System.Net.Sockets.ProtocolType protocolType) { }
+    public System.Net.Sockets.AddressFamily AddressFamily { get { return default(System.Net.Sockets.AddressFamily); } }
+    public int Available { get { return default(int); } }
+    public bool Blocking { get { return default(bool); } set { } }
+    public bool Connected { get { return default(bool); } }
+    public bool DontFragment { get { return default(bool); } set { } }
+    public bool DualMode { get { return default(bool); } set { } }
+    public bool EnableBroadcast { get { return default(bool); } set { } }
+    public bool ExclusiveAddressUse { get { return default(bool); } set { } }
+    public System.IntPtr Handle { get { return default(System.IntPtr); } }
+    public bool IsBound { get { return default(bool); } }
+    public System.Net.Sockets.LingerOption LingerState { get { return default(System.Net.Sockets.LingerOption); } set { } }
+    public System.Net.EndPoint LocalEndPoint { get { return default(System.Net.EndPoint); } }
+    public bool MulticastLoopback { get { return default(bool); } set { } }
+    public bool NoDelay { get { return default(bool); } set { } }
+    public static bool OSSupportsIPv4 { get { return default(bool); } }
+    public static bool OSSupportsIPv6 { get { return default(bool); } }
+    public System.Net.Sockets.ProtocolType ProtocolType { get { return default(System.Net.Sockets.ProtocolType); } }
+    public int ReceiveBufferSize { get { return default(int); } set { } }
+    public int ReceiveTimeout { get { return default(int); } set { } }
+    public System.Net.EndPoint RemoteEndPoint { get { return default(System.Net.EndPoint); } }
+    public int SendBufferSize { get { return default(int); } set { } }
+    public int SendTimeout { get { return default(int); } set { } }
+    public System.Net.Sockets.SocketType SocketType { get { return default(System.Net.Sockets.SocketType); } }
+    [System.ObsoleteAttribute("Use OSSupportsIPv4 instead")]
+    public static bool SupportsIPv4 { get { return default(bool); } }
+    [System.ObsoleteAttribute("Use OSSupportsIPv6 instead")]
+    public static bool SupportsIPv6 { get { return default(bool); } }
+    public short Ttl { get { return default(short); } set { } }
+    public bool UseOnlyOverlappedIO { get { return default(bool); } set { } }
+    public System.Net.Sockets.Socket Accept() { return default(System.Net.Sockets.Socket); }
+    public bool AcceptAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public System.IAsyncResult BeginAccept(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginAccept(int receiveSize, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginAccept(System.Net.Sockets.Socket acceptSocket, int receiveSize, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginConnect(System.Net.EndPoint end_point, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginConnect(System.Net.IPAddress address, int port, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginConnect(System.Net.IPAddress[] addresses, int port, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginConnect(string host, int port, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginDisconnect(bool reuseSocket, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginReceive(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socket_flags, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginReceive(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags flags, out System.Net.Sockets.SocketError error, System.AsyncCallback callback, object state) { error = default(System.Net.Sockets.SocketError); return default(System.IAsyncResult); }
+    [System.CLSCompliantAttribute(false)]
+    public System.IAsyncResult BeginReceive(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    [System.CLSCompliantAttribute(false)]
+    public System.IAsyncResult BeginReceive(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode, System.AsyncCallback callback, object state) { errorCode = default(System.Net.Sockets.SocketError); return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginReceiveFrom(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socket_flags, ref System.Net.EndPoint remote_end, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginReceiveMessageFrom(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSend(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socket_flags, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSend(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode, System.AsyncCallback callback, object state) { errorCode = default(System.Net.Sockets.SocketError); return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSend(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    [System.CLSCompliantAttribute(false)]
+    public System.IAsyncResult BeginSend(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode, System.AsyncCallback callback, object state) { errorCode = default(System.Net.Sockets.SocketError); return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSendFile(string fileName, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSendFile(string fileName, byte[] preBuffer, byte[] postBuffer, System.Net.Sockets.TransmitFileOptions flags, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSendTo(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socket_flags, System.Net.EndPoint remote_end, System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public void Bind(System.Net.EndPoint local_end) { }
+    public void Close() { }
+    public void Close(int timeout) { }
+    public void Connect(System.Net.EndPoint remoteEP) { }
+    public void Connect(System.Net.IPAddress address, int port) { }
+    public void Connect(System.Net.IPAddress[] addresses, int port) { }
+    public void Connect(string host, int port) { }
+    public bool ConnectAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public void Disconnect(bool reuseSocket) { }
+    public bool DisconnectAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public System.Net.Sockets.Socket EndAccept(out byte[] buffer, System.IAsyncResult asyncResult) { buffer = default(byte[]); return default(System.Net.Sockets.Socket); }
+    public System.Net.Sockets.Socket EndAccept(out byte[] buffer, out int bytesTransferred, System.IAsyncResult asyncResult) { buffer = default(byte[]); bytesTransferred = default(int); return default(System.Net.Sockets.Socket); }
+    public System.Net.Sockets.Socket EndAccept(System.IAsyncResult result) { return default(System.Net.Sockets.Socket); }
+    public void EndConnect(System.IAsyncResult result) { }
+    public void EndDisconnect(System.IAsyncResult asyncResult) { }
+    public int EndReceive(System.IAsyncResult result) { return default(int); }
+    public int EndReceive(System.IAsyncResult asyncResult, out System.Net.Sockets.SocketError errorCode) { errorCode = default(System.Net.Sockets.SocketError); return default(int); }
+    public int EndReceiveFrom(System.IAsyncResult result, ref System.Net.EndPoint end_point) { return default(int); }
+    public int EndReceiveMessageFrom(System.IAsyncResult asyncResult, ref System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint endPoint, out System.Net.Sockets.IPPacketInformation ipPacketInformation) { ipPacketInformation = default(System.Net.Sockets.IPPacketInformation); return default(int); }
+    public int EndSend(System.IAsyncResult result) { return default(int); }
+    public int EndSend(System.IAsyncResult asyncResult, out System.Net.Sockets.SocketError errorCode) { errorCode = default(System.Net.Sockets.SocketError); return default(int); }
+    public void EndSendFile(System.IAsyncResult asyncResult) { }
+    public int EndSendTo(System.IAsyncResult result) { return default(int); }
+    ~Socket() { }
+    public object GetSocketOption(System.Net.Sockets.SocketOptionLevel optionLevel, System.Net.Sockets.SocketOptionName optionName) { return default(object); }
+    public void GetSocketOption(System.Net.Sockets.SocketOptionLevel optionLevel, System.Net.Sockets.SocketOptionName optionName, byte[] optionValue) { }
+    public byte[] GetSocketOption(System.Net.Sockets.SocketOptionLevel optionLevel, System.Net.Sockets.SocketOptionName optionName, int length) { return default(byte[]); }
+    public int IOControl(int ioctl_code, byte[] in_value, byte[] out_value) { return default(int); }
+    public int IOControl(System.Net.Sockets.IOControlCode ioControlCode, byte[] optionInValue, byte[] optionOutValue) { return default(int); }
+    public void Listen(int backlog) { }
+    public bool Poll(int time_us, System.Net.Sockets.SelectMode mode) { return default(bool); }
+    public int Receive(byte[] buffer) { return default(int); }
+    public int Receive(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags flags) { return default(int); }
+    public int Receive(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags flags, out System.Net.Sockets.SocketError error) { error = default(System.Net.Sockets.SocketError); return default(int); }
+    public int Receive(byte[] buffer, int size, System.Net.Sockets.SocketFlags flags) { return default(int); }
+    public int Receive(byte[] buffer, System.Net.Sockets.SocketFlags flags) { return default(int); }
+    public int Receive(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    public int Receive(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    public int Receive(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode) { errorCode = default(System.Net.Sockets.SocketError); return default(int); }
+    public bool ReceiveAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public int ReceiveFrom(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags flags, ref System.Net.EndPoint remoteEP) { return default(int); }
+    public int ReceiveFrom(byte[] buffer, int size, System.Net.Sockets.SocketFlags flags, ref System.Net.EndPoint remoteEP) { return default(int); }
+    public int ReceiveFrom(byte[] buffer, ref System.Net.EndPoint remoteEP) { return default(int); }
+    public int ReceiveFrom(byte[] buffer, System.Net.Sockets.SocketFlags flags, ref System.Net.EndPoint remoteEP) { return default(int); }
+    public bool ReceiveFromAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref System.Net.Sockets.SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, out System.Net.Sockets.IPPacketInformation ipPacketInformation) { ipPacketInformation = default(System.Net.Sockets.IPPacketInformation); return default(int); }
+    public bool ReceiveMessageFromAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public static void Select(System.Collections.IList checkRead, System.Collections.IList checkWrite, System.Collections.IList checkError, int microSeconds) { }
+    public int Send(byte[] buffer) { return default(int); }
+    public int Send(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags flags) { return default(int); }
+    public int Send(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags flags, out System.Net.Sockets.SocketError error) { error = default(System.Net.Sockets.SocketError); return default(int); }
+    public int Send(byte[] buffer, int size, System.Net.Sockets.SocketFlags flags) { return default(int); }
+    public int Send(byte[] buffer, System.Net.Sockets.SocketFlags flags) { return default(int); }
+    public int Send(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers) { return default(int); }
+    public int Send(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    public int Send(System.Collections.Generic.IList<System.ArraySegment<byte>> buffers, System.Net.Sockets.SocketFlags socketFlags, out System.Net.Sockets.SocketError errorCode) { errorCode = default(System.Net.Sockets.SocketError); return default(int); }
+    public bool SendAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public void SendFile(string fileName) { }
+    public void SendFile(string fileName, byte[] preBuffer, byte[] postBuffer, System.Net.Sockets.TransmitFileOptions flags) { }
+    public bool SendPacketsAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public int SendTo(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags flags, System.Net.EndPoint remote_end) { return default(int); }
+    public int SendTo(byte[] buffer, int size, System.Net.Sockets.SocketFlags flags, System.Net.EndPoint remote_end) { return default(int); }
+    public int SendTo(byte[] buffer, System.Net.EndPoint remote_end) { return default(int); }
+    public int SendTo(byte[] buffer, System.Net.Sockets.SocketFlags flags, System.Net.EndPoint remote_end) { return default(int); }
+    public bool SendToAsync(System.Net.Sockets.SocketAsyncEventArgs e) { return default(bool); }
+    public void SetSocketOption(System.Net.Sockets.SocketOptionLevel optionLevel, System.Net.Sockets.SocketOptionName optionName, bool optionValue) { }
+    public void SetSocketOption(System.Net.Sockets.SocketOptionLevel optionLevel, System.Net.Sockets.SocketOptionName optionName, byte[] optionValue) { }
+    public void SetSocketOption(System.Net.Sockets.SocketOptionLevel optionLevel, System.Net.Sockets.SocketOptionName optionName, int optionValue) { }
+    public void SetSocketOption(System.Net.Sockets.SocketOptionLevel optionLevel, System.Net.Sockets.SocketOptionName optionName, object optionValue) { }
+    public void Shutdown(System.Net.Sockets.SocketShutdown how) { }
+  }
+
+  public partial class SocketAsyncEventArgs : System.EventArgs, System.IDisposable {
+    public SocketAsyncEventArgs() { }
+    public System.Net.Sockets.Socket AcceptSocket { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.Sockets.Socket); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public byte[] Buffer { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(byte[]); } }
+    public System.Collections.Generic.IList<System.ArraySegment<byte>> BufferList { get { return default(System.Collections.Generic.IList<System.ArraySegment<byte>>); } set { } }
+    public int BytesTransferred { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(int); } }
+    public System.Exception ConnectByNameError { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Exception); } }
+    public System.Net.Sockets.Socket ConnectSocket { get { return default(System.Net.Sockets.Socket); } }
+    public int Count { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(int); } }
+    public bool DisconnectReuseSocket { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public System.Net.Sockets.SocketAsyncOperation LastOperation { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.Sockets.SocketAsyncOperation); } }
+    public int Offset { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(int); } }
+    public System.Net.EndPoint RemoteEndPoint { get { return default(System.Net.EndPoint); } set { } }
+    public int SendPacketsSendSize { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(int); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public System.Net.Sockets.SocketError SocketError { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.Sockets.SocketError); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public System.Net.Sockets.SocketFlags SocketFlags { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.Sockets.SocketFlags); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public object UserToken { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(object); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public event System.EventHandler<System.Net.Sockets.SocketAsyncEventArgs> Completed { add { } remove { } }
+    public void Dispose() { }
+    ~SocketAsyncEventArgs() { }
+    protected virtual void OnCompleted(System.Net.Sockets.SocketAsyncEventArgs e) { }
+    public void SetBuffer(byte[] buffer, int offset, int count) { }
+    public void SetBuffer(int offset, int count) { }
+  }
+
+  public enum SocketAsyncOperation {
+    Accept = 1,
+    Connect = 2,
+    Disconnect = 3,
+    None = 0,
+    Receive = 4,
+    ReceiveFrom = 5,
+    ReceiveMessageFrom = 6,
+    Send = 7,
+    SendPackets = 8,
+    SendTo = 9,
+  }
+
+  [System.FlagsAttribute]
+  public enum SocketFlags {
+    Broadcast = 1024,
+    ControlDataTruncated = 512,
+    DontRoute = 4,
+    MaxIOVectorLength = 16,
+    Multicast = 2048,
+    None = 0,
+    OutOfBand = 1,
+    Partial = 32768,
+    Peek = 2,
+    Truncated = 256,
+  }
+
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct SocketInformation {
+    public System.Net.Sockets.SocketInformationOptions Options { get { return default(System.Net.Sockets.SocketInformationOptions); } set { } }
+    public byte[] ProtocolInformation { get { return default(byte[]); } set { } }
+  }
+
+  [System.FlagsAttribute]
+  public enum SocketInformationOptions {
+    Connected = 2,
+    Listening = 4,
+    NonBlocking = 1,
+    UseOnlyOverlappedIO = 8,
+  }
+
+  public enum SocketOptionLevel {
+    IP = 0,
+    IPv6 = 41,
+    Socket = 65535,
+    Tcp = 6,
+    Udp = 17,
+  }
+
+  public enum SocketOptionName {
+    AcceptConnection = 2,
+    AddMembership = 12,
+    AddSourceMembership = 15,
+    BlockSource = 17,
+    Broadcast = 32,
+    BsdUrgent = 2,
+    ChecksumCoverage = 20,
+    Debug = 1,
+    DontFragment = 14,
+    DontLinger = -129,
+    DontRoute = 16,
+    DropMembership = 13,
+    DropSourceMembership = 16,
+    Error = 4103,
+    ExclusiveAddressUse = -5,
+    Expedited = 2,
+    HeaderIncluded = 2,
+    HopLimit = 21,
+    IPOptions = 1,
+    IPProtectionLevel = 23,
+    IpTimeToLive = 4,
+    IPv6Only = 27,
+    KeepAlive = 8,
+    Linger = 128,
+    MaxConnections = 2147483647,
+    MulticastInterface = 9,
+    MulticastLoopback = 11,
+    MulticastTimeToLive = 10,
+    NoChecksum = 1,
+    NoDelay = 1,
+    OutOfBandInline = 256,
+    PacketInformation = 19,
+    ReceiveBuffer = 4098,
+    ReceiveLowWater = 4100,
+    ReceiveTimeout = 4102,
+    ReuseAddress = 4,
+    SendBuffer = 4097,
+    SendLowWater = 4099,
+    SendTimeout = 4101,
+    Type = 4104,
+    TypeOfService = 3,
+    UnblockSource = 18,
+    UpdateAcceptContext = 28683,
+    UpdateConnectContext = 28688,
+    UseLoopback = 64,
+  }
+
+  public enum SocketShutdown {
+    Both = 2,
+    Receive = 0,
+    Send = 1,
+  }
+
+  public enum SocketType {
+    Dgram = 2,
+    Raw = 3,
+    Rdm = 4,
+    Seqpacket = 5,
+    Stream = 1,
+    Unknown = -1,
+  }
+
+  public partial class TcpClient : System.IDisposable {
+    public TcpClient() { }
+    public TcpClient(System.Net.IPEndPoint localEP) { }
+    public TcpClient(System.Net.Sockets.AddressFamily family) { }
+    public TcpClient(string hostname, int port) { }
+    protected bool Active { get { return default(bool); } set { } }
+    public int Available { get { return default(int); } }
+    public System.Net.Sockets.Socket Client { get { return default(System.Net.Sockets.Socket); } set { } }
+    public bool Connected { get { return default(bool); } }
+    public bool ExclusiveAddressUse { get { return default(bool); } set { } }
+    public System.Net.Sockets.LingerOption LingerState { get { return default(System.Net.Sockets.LingerOption); } set { } }
+    public bool NoDelay { get { return default(bool); } set { } }
+    public int ReceiveBufferSize { get { return default(int); } set { } }
+    public int ReceiveTimeout { get { return default(int); } set { } }
+    public int SendBufferSize { get { return default(int); } set { } }
+    public int SendTimeout { get { return default(int); } set { } }
+    public System.IAsyncResult BeginConnect(System.Net.IPAddress address, int port, System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginConnect(System.Net.IPAddress[] addresses, int port, System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginConnect(string host, int port, System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    public void Close() { }
+    public void Connect(System.Net.IPAddress address, int port) { }
+    public void Connect(System.Net.IPAddress[] ipAddresses, int port) { }
+    public void Connect(System.Net.IPEndPoint remoteEP) { }
+    public void Connect(string hostname, int port) { }
+    public System.Threading.Tasks.Task ConnectAsync(System.Net.IPAddress address, int port) { return default(System.Threading.Tasks.Task); }
+    public System.Threading.Tasks.Task ConnectAsync(System.Net.IPAddress[] addresses, int port) { return default(System.Threading.Tasks.Task); }
+    public System.Threading.Tasks.Task ConnectAsync(string host, int port) { return default(System.Threading.Tasks.Task); }
+    protected virtual void Dispose(bool disposing) { }
+    public void EndConnect(System.IAsyncResult asyncResult) { }
+    ~TcpClient() { }
+    public System.Net.Sockets.NetworkStream GetStream() { return default(System.Net.Sockets.NetworkStream); }
+    void System.IDisposable.Dispose() { }
+  }
+
+  public partial class TcpListener {
+    [System.ObsoleteAttribute("Use TcpListener (IPAddress address, int port) instead")]
+    public TcpListener(int port) { }
+    public TcpListener(System.Net.IPAddress localaddr, int port) { }
+    public TcpListener(System.Net.IPEndPoint localEP) { }
+    protected bool Active { get { return default(bool); } }
+    public bool ExclusiveAddressUse { get { return default(bool); } set { } }
+    public System.Net.EndPoint LocalEndpoint { get { return default(System.Net.EndPoint); } }
+    public System.Net.Sockets.Socket Server { get { return default(System.Net.Sockets.Socket); } }
+    public System.Net.Sockets.Socket AcceptSocket() { return default(System.Net.Sockets.Socket); }
+    public System.Threading.Tasks.Task<System.Net.Sockets.Socket> AcceptSocketAsync() { return default(System.Threading.Tasks.Task<System.Net.Sockets.Socket>); }
+    public System.Net.Sockets.TcpClient AcceptTcpClient() { return default(System.Net.Sockets.TcpClient); }
+    public System.Threading.Tasks.Task<System.Net.Sockets.TcpClient> AcceptTcpClientAsync() { return default(System.Threading.Tasks.Task<System.Net.Sockets.TcpClient>); }
+    public System.IAsyncResult BeginAcceptSocket(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginAcceptTcpClient(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public System.Net.Sockets.Socket EndAcceptSocket(System.IAsyncResult asyncResult) { return default(System.Net.Sockets.Socket); }
+    public System.Net.Sockets.TcpClient EndAcceptTcpClient(System.IAsyncResult asyncResult) { return default(System.Net.Sockets.TcpClient); }
+    ~TcpListener() { }
+    public bool Pending() { return default(bool); }
+    public void Start() { }
+    public void Start(int backlog) { }
+    public void Stop() { }
+  }
+
+  [System.FlagsAttribute]
+  public enum TransmitFileOptions {
+    Disconnect = 1,
+    ReuseSocket = 2,
+    UseDefaultWorkerThread = 0,
+    UseKernelApc = 32,
+    UseSystemThread = 16,
+    WriteBehind = 4,
+  }
+
+  public partial class UdpClient : System.IDisposable {
+    public UdpClient() { }
+    public UdpClient(int port) { }
+    public UdpClient(int port, System.Net.Sockets.AddressFamily family) { }
+    public UdpClient(System.Net.IPEndPoint localEP) { }
+    public UdpClient(System.Net.Sockets.AddressFamily family) { }
+    public UdpClient(string hostname, int port) { }
+    protected bool Active { get { return default(bool); } set { } }
+    public int Available { get { return default(int); } }
+    public System.Net.Sockets.Socket Client { get { return default(System.Net.Sockets.Socket); } set { } }
+    public bool DontFragment { get { return default(bool); } set { } }
+    public bool EnableBroadcast { get { return default(bool); } set { } }
+    public bool ExclusiveAddressUse { get { return default(bool); } set { } }
+    public bool MulticastLoopback { get { return default(bool); } set { } }
+    public short Ttl { get { return default(short); } set { } }
+    public System.IAsyncResult BeginReceive(System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSend(byte[] datagram, int bytes, System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSend(byte[] datagram, int bytes, System.Net.IPEndPoint endPoint, System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    public System.IAsyncResult BeginSend(byte[] datagram, int bytes, string hostname, int port, System.AsyncCallback requestCallback, object state) { return default(System.IAsyncResult); }
+    public void Close() { }
+    public void Connect(System.Net.IPAddress addr, int port) { }
+    public void Connect(System.Net.IPEndPoint endPoint) { }
+    public void Connect(string hostname, int port) { }
+    protected virtual void Dispose(bool disposing) { }
+    public void DropMulticastGroup(System.Net.IPAddress multicastAddr) { }
+    public void DropMulticastGroup(System.Net.IPAddress multicastAddr, int ifindex) { }
+    public byte[] EndReceive(System.IAsyncResult asyncResult, ref System.Net.IPEndPoint remoteEP) { return default(byte[]); }
+    public int EndSend(System.IAsyncResult asyncResult) { return default(int); }
+    ~UdpClient() { }
+    public void JoinMulticastGroup(int ifindex, System.Net.IPAddress multicastAddr) { }
+    public void JoinMulticastGroup(System.Net.IPAddress multicastAddr) { }
+    public void JoinMulticastGroup(System.Net.IPAddress multicastAddr, int timeToLive) { }
+    public void JoinMulticastGroup(System.Net.IPAddress multicastAddr, System.Net.IPAddress localAddress) { }
+    public byte[] Receive(ref System.Net.IPEndPoint remoteEP) { return default(byte[]); }
+    public System.Threading.Tasks.Task<System.Net.Sockets.UdpReceiveResult> ReceiveAsync() { return default(System.Threading.Tasks.Task<System.Net.Sockets.UdpReceiveResult>); }
+    public int Send(byte[] dgram, int bytes) { return default(int); }
+    public int Send(byte[] dgram, int bytes, System.Net.IPEndPoint endPoint) { return default(int); }
+    public int Send(byte[] dgram, int bytes, string hostname, int port) { return default(int); }
+    public System.Threading.Tasks.Task<int> SendAsync(byte[] datagram, int bytes) { return default(System.Threading.Tasks.Task<int>); }
+    public System.Threading.Tasks.Task<int> SendAsync(byte[] datagram, int bytes, System.Net.IPEndPoint endPoint) { return default(System.Threading.Tasks.Task<int>); }
+    public System.Threading.Tasks.Task<int> SendAsync(byte[] datagram, int bytes, string hostname, int port) { return default(System.Threading.Tasks.Task<int>); }
+    void System.IDisposable.Dispose() { }
+  }
+
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+  public partial struct UdpReceiveResult : System.IEquatable<System.Net.Sockets.UdpReceiveResult> {
+    public UdpReceiveResult(byte[] buffer, System.Net.IPEndPoint remoteEndPoint) { throw new System.NotImplementedException(); }
+    public byte[] Buffer { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(byte[]); } }
+    public System.Net.IPEndPoint RemoteEndPoint { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.IPEndPoint); } }
+    public bool Equals(System.Net.Sockets.UdpReceiveResult other) { return default(bool); }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public static bool operator ==(System.Net.Sockets.UdpReceiveResult left, System.Net.Sockets.UdpReceiveResult right) { return default(bool); }
+    public static bool operator !=(System.Net.Sockets.UdpReceiveResult left, System.Net.Sockets.UdpReceiveResult right) { return default(bool); }
+  }
+
+} // end of System.Net.Sockets

fxdac/fxdac/Data/Contracts/System.Net.WebClient.cs

@@ -0,0 +1,250 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  public partial class DownloadDataCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal DownloadDataCompletedEventArgs() { }
+    public byte[] Result { get { return default(byte[]); } }
+  }
+
+  public delegate void DownloadDataCompletedEventHandler(object sender, System.Net.DownloadDataCompletedEventArgs e);
+
+  public partial class DownloadProgressChangedEventArgs : System.ComponentModel.ProgressChangedEventArgs {
+    internal DownloadProgressChangedEventArgs() : base (default(int), default(object)) { }
+    public long BytesReceived { get { return default(long); } }
+    public long TotalBytesToReceive { get { return default(long); } }
+  }
+
+  public delegate void DownloadProgressChangedEventHandler(object sender, System.Net.DownloadProgressChangedEventArgs e);
+
+  public partial class DownloadStringCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal DownloadStringCompletedEventArgs() { }
+    public string Result { get { return default(string); } }
+  }
+
+  public delegate void DownloadStringCompletedEventHandler(object sender, System.Net.DownloadStringCompletedEventArgs e);
+
+  public partial class OpenReadCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal OpenReadCompletedEventArgs() { }
+    public System.IO.Stream Result { get { return default(System.IO.Stream); } }
+  }
+
+  public delegate void OpenReadCompletedEventHandler(object sender, System.Net.OpenReadCompletedEventArgs e);
+
+  public partial class OpenWriteCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal OpenWriteCompletedEventArgs() { }
+    public System.IO.Stream Result { get { return default(System.IO.Stream); } }
+  }
+
+  public delegate void OpenWriteCompletedEventHandler(object sender, System.Net.OpenWriteCompletedEventArgs e);
+
+  public partial class UploadDataCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal UploadDataCompletedEventArgs() { }
+    public byte[] Result { get { return default(byte[]); } }
+  }
+
+  public delegate void UploadDataCompletedEventHandler(object sender, System.Net.UploadDataCompletedEventArgs e);
+
+  public partial class UploadFileCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal UploadFileCompletedEventArgs() { }
+    public byte[] Result { get { return default(byte[]); } }
+  }
+
+  public delegate void UploadFileCompletedEventHandler(object sender, System.Net.UploadFileCompletedEventArgs e);
+
+  public partial class UploadProgressChangedEventArgs : System.ComponentModel.ProgressChangedEventArgs {
+    internal UploadProgressChangedEventArgs() : base (default(int), default(object)) { }
+    public long BytesReceived { get { return default(long); } }
+    public long BytesSent { get { return default(long); } }
+    public long TotalBytesToReceive { get { return default(long); } }
+    public long TotalBytesToSend { get { return default(long); } }
+  }
+
+  public delegate void UploadProgressChangedEventHandler(object sender, System.Net.UploadProgressChangedEventArgs e);
+
+  public partial class UploadStringCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal UploadStringCompletedEventArgs() { }
+    public string Result { get { return default(string); } }
+  }
+
+  public delegate void UploadStringCompletedEventHandler(object sender, System.Net.UploadStringCompletedEventArgs e);
+
+  public partial class UploadValuesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+    internal UploadValuesCompletedEventArgs() { }
+    public byte[] Result { get { return default(byte[]); } }
+  }
+
+  public delegate void UploadValuesCompletedEventHandler(object sender, System.Net.UploadValuesCompletedEventArgs e);
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class WebClient : System.ComponentModel.Component {
+    public WebClient() { }
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+    [System.ObsoleteAttribute("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
+    public bool AllowReadStreamBuffering { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+    [System.ObsoleteAttribute("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
+    public bool AllowWriteStreamBuffering { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public string BaseAddress { get { return default(string); } set { } }
+    public System.Net.Cache.RequestCachePolicy CachePolicy { get { return default(System.Net.Cache.RequestCachePolicy); } set { } }
+    public System.Net.ICredentials Credentials { get { return default(System.Net.ICredentials); } set { } }
+    public System.Text.Encoding Encoding { get { return default(System.Text.Encoding); } set { } }
+    public System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } set { } }
+    public bool IsBusy { get { return default(bool); } }
+    public System.Net.IWebProxy Proxy { get { return default(System.Net.IWebProxy); } set { } }
+    public System.Collections.Specialized.NameValueCollection QueryString { get { return default(System.Collections.Specialized.NameValueCollection); } set { } }
+    public System.Net.WebHeaderCollection ResponseHeaders { get { return default(System.Net.WebHeaderCollection); } }
+    public bool UseDefaultCredentials { get { return default(bool); } set { } }
+    public event System.Net.DownloadDataCompletedEventHandler DownloadDataCompleted { add { } remove { } }
+    public event System.ComponentModel.AsyncCompletedEventHandler DownloadFileCompleted { add { } remove { } }
+    public event System.Net.DownloadProgressChangedEventHandler DownloadProgressChanged { add { } remove { } }
+    public event System.Net.DownloadStringCompletedEventHandler DownloadStringCompleted { add { } remove { } }
+    public event System.Net.OpenReadCompletedEventHandler OpenReadCompleted { add { } remove { } }
+    public event System.Net.OpenWriteCompletedEventHandler OpenWriteCompleted { add { } remove { } }
+    public event System.Net.UploadDataCompletedEventHandler UploadDataCompleted { add { } remove { } }
+    public event System.Net.UploadFileCompletedEventHandler UploadFileCompleted { add { } remove { } }
+    public event System.Net.UploadProgressChangedEventHandler UploadProgressChanged { add { } remove { } }
+    public event System.Net.UploadStringCompletedEventHandler UploadStringCompleted { add { } remove { } }
+    public event System.Net.UploadValuesCompletedEventHandler UploadValuesCompleted { add { } remove { } }
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+    [System.ObsoleteAttribute("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
+    public event System.Net.WriteStreamClosedEventHandler WriteStreamClosed { add { } remove { } }
+    public void CancelAsync() { }
+    public byte[] DownloadData(string address) { return default(byte[]); }
+    public byte[] DownloadData(System.Uri address) { return default(byte[]); }
+    public void DownloadDataAsync(System.Uri address) { }
+    public void DownloadDataAsync(System.Uri address, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> DownloadDataTaskAsync(string address) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> DownloadDataTaskAsync(System.Uri address) { return default(System.Threading.Tasks.Task<byte[]>); }
+    public void DownloadFile(string address, string fileName) { }
+    public void DownloadFile(System.Uri address, string fileName) { }
+    public void DownloadFileAsync(System.Uri address, string fileName) { }
+    public void DownloadFileAsync(System.Uri address, string fileName, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileName) { return default(System.Threading.Tasks.Task); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task DownloadFileTaskAsync(System.Uri address, string fileName) { return default(System.Threading.Tasks.Task); }
+    public string DownloadString(string address) { return default(string); }
+    public string DownloadString(System.Uri address) { return default(string); }
+    public void DownloadStringAsync(System.Uri address) { }
+    public void DownloadStringAsync(System.Uri address, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<string> DownloadStringTaskAsync(string address) { return default(System.Threading.Tasks.Task<string>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<string> DownloadStringTaskAsync(System.Uri address) { return default(System.Threading.Tasks.Task<string>); }
+    protected virtual System.Net.WebRequest GetWebRequest(System.Uri address) { return default(System.Net.WebRequest); }
+    protected virtual System.Net.WebResponse GetWebResponse(System.Net.WebRequest request) { return default(System.Net.WebResponse); }
+    protected virtual System.Net.WebResponse GetWebResponse(System.Net.WebRequest request, System.IAsyncResult result) { return default(System.Net.WebResponse); }
+    protected virtual void OnDownloadDataCompleted(System.Net.DownloadDataCompletedEventArgs e) { }
+    protected virtual void OnDownloadFileCompleted(System.ComponentModel.AsyncCompletedEventArgs e) { }
+    protected virtual void OnDownloadProgressChanged(System.Net.DownloadProgressChangedEventArgs e) { }
+    protected virtual void OnDownloadStringCompleted(System.Net.DownloadStringCompletedEventArgs e) { }
+    protected virtual void OnOpenReadCompleted(System.Net.OpenReadCompletedEventArgs e) { }
+    protected virtual void OnOpenWriteCompleted(System.Net.OpenWriteCompletedEventArgs e) { }
+    protected virtual void OnUploadDataCompleted(System.Net.UploadDataCompletedEventArgs e) { }
+    protected virtual void OnUploadFileCompleted(System.Net.UploadFileCompletedEventArgs e) { }
+    protected virtual void OnUploadProgressChanged(System.Net.UploadProgressChangedEventArgs e) { }
+    protected virtual void OnUploadStringCompleted(System.Net.UploadStringCompletedEventArgs e) { }
+    protected virtual void OnUploadValuesCompleted(System.Net.UploadValuesCompletedEventArgs e) { }
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+    [System.ObsoleteAttribute("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
+    protected virtual void OnWriteStreamClosed(System.Net.WriteStreamClosedEventArgs e) { }
+    public System.IO.Stream OpenRead(string address) { return default(System.IO.Stream); }
+    public System.IO.Stream OpenRead(System.Uri address) { return default(System.IO.Stream); }
+    public void OpenReadAsync(System.Uri address) { }
+    public void OpenReadAsync(System.Uri address, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<System.IO.Stream> OpenReadTaskAsync(string address) { return default(System.Threading.Tasks.Task<System.IO.Stream>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<System.IO.Stream> OpenReadTaskAsync(System.Uri address) { return default(System.Threading.Tasks.Task<System.IO.Stream>); }
+    public System.IO.Stream OpenWrite(string address) { return default(System.IO.Stream); }
+    public System.IO.Stream OpenWrite(string address, string method) { return default(System.IO.Stream); }
+    public System.IO.Stream OpenWrite(System.Uri address) { return default(System.IO.Stream); }
+    public System.IO.Stream OpenWrite(System.Uri address, string method) { return default(System.IO.Stream); }
+    public void OpenWriteAsync(System.Uri address) { }
+    public void OpenWriteAsync(System.Uri address, string method) { }
+    public void OpenWriteAsync(System.Uri address, string method, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<System.IO.Stream> OpenWriteTaskAsync(string address) { return default(System.Threading.Tasks.Task<System.IO.Stream>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<System.IO.Stream> OpenWriteTaskAsync(string address, string method) { return default(System.Threading.Tasks.Task<System.IO.Stream>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<System.IO.Stream> OpenWriteTaskAsync(System.Uri address) { return default(System.Threading.Tasks.Task<System.IO.Stream>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<System.IO.Stream> OpenWriteTaskAsync(System.Uri address, string method) { return default(System.Threading.Tasks.Task<System.IO.Stream>); }
+    public byte[] UploadData(string address, byte[] data) { return default(byte[]); }
+    public byte[] UploadData(string address, string method, byte[] data) { return default(byte[]); }
+    public byte[] UploadData(System.Uri address, byte[] data) { return default(byte[]); }
+    public byte[] UploadData(System.Uri address, string method, byte[] data) { return default(byte[]); }
+    public void UploadDataAsync(System.Uri address, byte[] data) { }
+    public void UploadDataAsync(System.Uri address, string method, byte[] data) { }
+    public void UploadDataAsync(System.Uri address, string method, byte[] data, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadDataTaskAsync(string address, byte[] data) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadDataTaskAsync(string address, string method, byte[] data) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadDataTaskAsync(System.Uri address, byte[] data) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadDataTaskAsync(System.Uri address, string method, byte[] data) { return default(System.Threading.Tasks.Task<byte[]>); }
+    public byte[] UploadFile(string address, string fileName) { return default(byte[]); }
+    public byte[] UploadFile(string address, string method, string fileName) { return default(byte[]); }
+    public byte[] UploadFile(System.Uri address, string fileName) { return default(byte[]); }
+    public byte[] UploadFile(System.Uri address, string method, string fileName) { return default(byte[]); }
+    public void UploadFileAsync(System.Uri address, string fileName) { }
+    public void UploadFileAsync(System.Uri address, string method, string fileName) { }
+    public void UploadFileAsync(System.Uri address, string method, string fileName, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadFileTaskAsync(string address, string fileName) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadFileTaskAsync(string address, string method, string fileName) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadFileTaskAsync(System.Uri address, string fileName) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadFileTaskAsync(System.Uri address, string method, string fileName) { return default(System.Threading.Tasks.Task<byte[]>); }
+    public string UploadString(string address, string data) { return default(string); }
+    public string UploadString(string address, string method, string data) { return default(string); }
+    public string UploadString(System.Uri address, string data) { return default(string); }
+    public string UploadString(System.Uri address, string method, string data) { return default(string); }
+    public void UploadStringAsync(System.Uri address, string data) { }
+    public void UploadStringAsync(System.Uri address, string method, string data) { }
+    public void UploadStringAsync(System.Uri address, string method, string data, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<string> UploadStringTaskAsync(string address, string data) { return default(System.Threading.Tasks.Task<string>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<string> UploadStringTaskAsync(string address, string method, string data) { return default(System.Threading.Tasks.Task<string>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<string> UploadStringTaskAsync(System.Uri address, string data) { return default(System.Threading.Tasks.Task<string>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<string> UploadStringTaskAsync(System.Uri address, string method, string data) { return default(System.Threading.Tasks.Task<string>); }
+    public byte[] UploadValues(string address, System.Collections.Specialized.NameValueCollection data) { return default(byte[]); }
+    public byte[] UploadValues(string address, string method, System.Collections.Specialized.NameValueCollection data) { return default(byte[]); }
+    public byte[] UploadValues(System.Uri address, System.Collections.Specialized.NameValueCollection data) { return default(byte[]); }
+    public byte[] UploadValues(System.Uri address, string method, System.Collections.Specialized.NameValueCollection data) { return default(byte[]); }
+    public void UploadValuesAsync(System.Uri address, System.Collections.Specialized.NameValueCollection data) { }
+    public void UploadValuesAsync(System.Uri address, string method, System.Collections.Specialized.NameValueCollection data) { }
+    public void UploadValuesAsync(System.Uri address, string method, System.Collections.Specialized.NameValueCollection data, object userToken) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadValuesTaskAsync(string address, System.Collections.Specialized.NameValueCollection data) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadValuesTaskAsync(string address, string method, System.Collections.Specialized.NameValueCollection data) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadValuesTaskAsync(System.Uri address, System.Collections.Specialized.NameValueCollection data) { return default(System.Threading.Tasks.Task<byte[]>); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.Tasks.Task<byte[]> UploadValuesTaskAsync(System.Uri address, string method, System.Collections.Specialized.NameValueCollection data) { return default(System.Threading.Tasks.Task<byte[]>); }
+  }
+
+  [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+  public partial class WriteStreamClosedEventArgs : System.EventArgs {
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+    [System.ObsoleteAttribute("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
+    public WriteStreamClosedEventArgs() { }
+    [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+    [System.ObsoleteAttribute("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
+    public System.Exception Error { get { return default(System.Exception); } }
+  }
+
+  [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+  public delegate void WriteStreamClosedEventHandler(object sender, System.Net.WriteStreamClosedEventArgs e);
+
+} // end of System.Net

fxdac/fxdac/Data/Contracts/System.Net.WebHeaderCollection.cs

@@ -0,0 +1,116 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  public enum HttpRequestHeader {
+    Accept = 20,
+    AcceptCharset = 21,
+    AcceptEncoding = 22,
+    AcceptLanguage = 23,
+    Allow = 10,
+    Authorization = 24,
+    CacheControl = 0,
+    Connection = 1,
+    ContentEncoding = 13,
+    ContentLanguage = 14,
+    ContentLength = 11,
+    ContentLocation = 15,
+    ContentMd5 = 16,
+    ContentRange = 17,
+    ContentType = 12,
+    Cookie = 25,
+    Date = 2,
+    Expect = 26,
+    Expires = 18,
+    From = 27,
+    Host = 28,
+    IfMatch = 29,
+    IfModifiedSince = 30,
+    IfNoneMatch = 31,
+    IfRange = 32,
+    IfUnmodifiedSince = 33,
+    KeepAlive = 3,
+    LastModified = 19,
+    MaxForwards = 34,
+    Pragma = 4,
+    ProxyAuthorization = 35,
+    Range = 37,
+    Referer = 36,
+    Te = 38,
+    Trailer = 5,
+    TransferEncoding = 6,
+    Translate = 39,
+    Upgrade = 7,
+    UserAgent = 40,
+    Via = 8,
+    Warning = 9,
+  }
+
+  public enum HttpResponseHeader {
+    AcceptRanges = 20,
+    Age = 21,
+    Allow = 10,
+    CacheControl = 0,
+    Connection = 1,
+    ContentEncoding = 13,
+    ContentLanguage = 14,
+    ContentLength = 11,
+    ContentLocation = 15,
+    ContentMd5 = 16,
+    ContentRange = 17,
+    ContentType = 12,
+    Date = 2,
+    ETag = 22,
+    Expires = 18,
+    KeepAlive = 3,
+    LastModified = 19,
+    Location = 23,
+    Pragma = 4,
+    ProxyAuthenticate = 24,
+    RetryAfter = 25,
+    Server = 26,
+    SetCookie = 27,
+    Trailer = 5,
+    TransferEncoding = 6,
+    Upgrade = 7,
+    Vary = 28,
+    Via = 8,
+    Warning = 9,
+    WwwAuthenticate = 29,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class WebHeaderCollection : System.Collections.Specialized.NameValueCollection, System.Runtime.Serialization.ISerializable {
+    public WebHeaderCollection() { }
+    protected WebHeaderCollection(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override string[] AllKeys { get { return default(string[]); } }
+    public override int Count { get { return default(int); } }
+    public string this[System.Net.HttpRequestHeader header] { get { return default(string); } set { } }
+    public string this[System.Net.HttpResponseHeader header] { get { return default(string); } set { } }
+    public override System.Collections.Specialized.NameObjectCollectionBase.KeysCollection Keys { get { return default(System.Collections.Specialized.NameObjectCollectionBase.KeysCollection); } }
+    public void Add(System.Net.HttpRequestHeader header, string value) { }
+    public void Add(System.Net.HttpResponseHeader header, string value) { }
+    public void Add(string header) { }
+    public override void Add(string name, string value) { }
+    protected void AddWithoutValidate(string headerName, string headerValue) { }
+    public override void Clear() { }
+    public override string Get(int index) { return default(string); }
+    public override string Get(string name) { return default(string); }
+    public override System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public override string GetKey(int index) { return default(string); }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override string[] GetValues(int index) { return default(string[]); }
+    public override string[] GetValues(string header) { return default(string[]); }
+    public static bool IsRestricted(string headerName) { return default(bool); }
+    public static bool IsRestricted(string headerName, bool response) { return default(bool); }
+    public override void OnDeserialization(object sender) { }
+    public void Remove(System.Net.HttpRequestHeader header) { }
+    public void Remove(System.Net.HttpResponseHeader header) { }
+    public override void Remove(string name) { }
+    public void Set(System.Net.HttpRequestHeader header, string value) { }
+    public void Set(System.Net.HttpResponseHeader header, string value) { }
+    public override void Set(string name, string value) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public byte[] ToByteArray() { return default(byte[]); }
+    public override string ToString() { return default(string); }
+  }
+
+} // end of System.Net

fxdac/fxdac/Data/Contracts/System.Net.WebSockets.cs

@@ -0,0 +1,161 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net.WebSockets {
+  public partial class ClientWebSocket : System.Net.WebSockets.WebSocket, System.IDisposable {
+    public ClientWebSocket() { }
+    public override System.Nullable<System.Net.WebSockets.WebSocketCloseStatus> CloseStatus { get { return default(System.Nullable<System.Net.WebSockets.WebSocketCloseStatus>); } }
+    public override string CloseStatusDescription { get { return default(string); } }
+    public System.Net.WebSockets.ClientWebSocketOptions Options { get { return default(System.Net.WebSockets.ClientWebSocketOptions); } }
+    public override System.Net.WebSockets.WebSocketState State { get { return default(System.Net.WebSockets.WebSocketState); } }
+    public override string SubProtocol { get { return default(string); } }
+    public override void Abort() { }
+    [System.Diagnostics.DebuggerStepThroughAttribute]
+    public override System.Threading.Tasks.Task CloseAsync(System.Net.WebSockets.WebSocketCloseStatus closeStatus, string statusDescription, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    [System.Diagnostics.DebuggerStepThroughAttribute]
+    public override System.Threading.Tasks.Task CloseOutputAsync(System.Net.WebSockets.WebSocketCloseStatus closeStatus, string statusDescription, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    [System.Diagnostics.DebuggerStepThroughAttribute]
+    public System.Threading.Tasks.Task ConnectAsync(System.Uri uri, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    public override void Dispose() { }
+    public override System.Threading.Tasks.Task<System.Net.WebSockets.WebSocketReceiveResult> ReceiveAsync(System.ArraySegment<byte> buffer, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<System.Net.WebSockets.WebSocketReceiveResult>); }
+    public override System.Threading.Tasks.Task SendAsync(System.ArraySegment<byte> buffer, System.Net.WebSockets.WebSocketMessageType messageType, bool endOfMessage, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+  }
+
+  public sealed partial class ClientWebSocketOptions {
+    public ClientWebSocketOptions() { }
+    public System.Security.Cryptography.X509Certificates.X509CertificateCollection ClientCertificates { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Security.Cryptography.X509Certificates.X509CertificateCollection); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public System.Net.CookieContainer Cookies { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.CookieContainer); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public System.Net.ICredentials Credentials { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.ICredentials); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public System.TimeSpan KeepAliveInterval { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.TimeSpan); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public System.Net.IWebProxy Proxy { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.IWebProxy); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public bool UseDefaultCredentials { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public void AddSubProtocol(string subProtocol) { }
+    public void SetBuffer(int receiveBufferSize, int sendBufferSize) { }
+    public void SetBuffer(int receiveBufferSize, int sendBufferSize, System.ArraySegment<byte> buffer) { }
+    public void SetRequestHeader(string headerName, string headerValue) { }
+  }
+
+  public partial class HttpListenerWebSocketContext : System.Net.WebSockets.WebSocketContext {
+    public HttpListenerWebSocketContext() { }
+    public override System.Net.CookieCollection CookieCollection { get { return default(System.Net.CookieCollection); } }
+    public override System.Collections.Specialized.NameValueCollection Headers { get { return default(System.Collections.Specialized.NameValueCollection); } }
+    public override bool IsAuthenticated { get { return default(bool); } }
+    public override bool IsLocal { get { return default(bool); } }
+    public override bool IsSecureConnection { get { return default(bool); } }
+    public override string Origin { get { return default(string); } }
+    public override System.Uri RequestUri { get { return default(System.Uri); } }
+    public override string SecWebSocketKey { get { return default(string); } }
+    public override System.Collections.Generic.IEnumerable<string> SecWebSocketProtocols { get { return default(System.Collections.Generic.IEnumerable<string>); } }
+    public override string SecWebSocketVersion { get { return default(string); } }
+    public override System.Security.Principal.IPrincipal User { get { return default(System.Security.Principal.IPrincipal); } }
+    public override System.Net.WebSockets.WebSocket WebSocket { get { return default(System.Net.WebSockets.WebSocket); } }
+  }
+
+  public abstract partial class WebSocket : System.IDisposable {
+    protected WebSocket() { }
+    public abstract System.Nullable<System.Net.WebSockets.WebSocketCloseStatus> CloseStatus { get; }
+    public abstract string CloseStatusDescription { get; }
+    public static System.TimeSpan DefaultKeepAliveInterval { get { return default(System.TimeSpan); } }
+    public abstract System.Net.WebSockets.WebSocketState State { get; }
+    public abstract string SubProtocol { get; }
+    public abstract void Abort();
+    public abstract System.Threading.Tasks.Task CloseAsync(System.Net.WebSockets.WebSocketCloseStatus closeStatus, string statusDescription, System.Threading.CancellationToken cancellationToken);
+    public abstract System.Threading.Tasks.Task CloseOutputAsync(System.Net.WebSockets.WebSocketCloseStatus closeStatus, string statusDescription, System.Threading.CancellationToken cancellationToken);
+    public static System.ArraySegment<byte> CreateClientBuffer(int receiveBufferSize, int sendBufferSize) { return default(System.ArraySegment<byte>); }
+    public static System.Net.WebSockets.WebSocket CreateClientWebSocket(System.IO.Stream innerStream, string subProtocol, int receiveBufferSize, int sendBufferSize, System.TimeSpan keepAliveInterval, bool useZeroMaskingKey, System.ArraySegment<byte> internalBuffer) { return default(System.Net.WebSockets.WebSocket); }
+    public static System.ArraySegment<byte> CreateServerBuffer(int receiveBufferSize) { return default(System.ArraySegment<byte>); }
+    public abstract void Dispose();
+    [System.ObsoleteAttribute]
+    public static bool IsApplicationTargeting45() { return default(bool); }
+    protected static bool IsStateTerminal(System.Net.WebSockets.WebSocketState state) { return default(bool); }
+    public abstract System.Threading.Tasks.Task<System.Net.WebSockets.WebSocketReceiveResult> ReceiveAsync(System.ArraySegment<byte> buffer, System.Threading.CancellationToken cancellationToken);
+    public static void RegisterPrefixes() { }
+    public abstract System.Threading.Tasks.Task SendAsync(System.ArraySegment<byte> buffer, System.Net.WebSockets.WebSocketMessageType messageType, bool endOfMessage, System.Threading.CancellationToken cancellationToken);
+    protected static void ThrowOnInvalidState(System.Net.WebSockets.WebSocketState state, params System.Net.WebSockets.WebSocketState[] validStates) { }
+  }
+
+  public enum WebSocketCloseStatus {
+    Empty = 1004,
+    EndpointUnavailable = 1001,
+    InternalServerError = 1011,
+    InvalidMessageType = 1003,
+    InvalidPayloadData = 1007,
+    MandatoryExtension = 1010,
+    MessageTooBig = 1004,
+    NormalClosure = 1000,
+    PolicyViolation = 1008,
+    ProtocolError = 1002,
+  }
+
+  public abstract partial class WebSocketContext {
+    protected WebSocketContext() { }
+    public abstract System.Net.CookieCollection CookieCollection { get; }
+    public abstract System.Collections.Specialized.NameValueCollection Headers { get; }
+    public abstract bool IsAuthenticated { get; }
+    public abstract bool IsLocal { get; }
+    public abstract bool IsSecureConnection { get; }
+    public abstract string Origin { get; }
+    public abstract System.Uri RequestUri { get; }
+    public abstract string SecWebSocketKey { get; }
+    public abstract System.Collections.Generic.IEnumerable<string> SecWebSocketProtocols { get; }
+    public abstract string SecWebSocketVersion { get; }
+    public abstract System.Security.Principal.IPrincipal User { get; }
+    public abstract System.Net.WebSockets.WebSocket WebSocket { get; }
+  }
+
+  public enum WebSocketError {
+    ConnectionClosedPrematurely = 8,
+    Faulted = 2,
+    HeaderError = 7,
+    InvalidMessageType = 1,
+    InvalidState = 9,
+    NativeError = 3,
+    NotAWebSocket = 4,
+    Success = 0,
+    UnsupportedProtocol = 6,
+    UnsupportedVersion = 5,
+  }
+
+  public sealed partial class WebSocketException : System.ComponentModel.Win32Exception {
+    public WebSocketException() { }
+    public WebSocketException(int nativeError) { }
+    public WebSocketException(int nativeError, System.Exception innerException) { }
+    public WebSocketException(int nativeError, string message) { }
+    public WebSocketException(System.Net.WebSockets.WebSocketError error) { }
+    public WebSocketException(System.Net.WebSockets.WebSocketError error, System.Exception innerException) { }
+    public WebSocketException(System.Net.WebSockets.WebSocketError error, int nativeError) { }
+    public WebSocketException(System.Net.WebSockets.WebSocketError error, int nativeError, System.Exception innerException) { }
+    public WebSocketException(System.Net.WebSockets.WebSocketError error, int nativeError, string message) { }
+    public WebSocketException(System.Net.WebSockets.WebSocketError error, int nativeError, string message, System.Exception innerException) { }
+    public WebSocketException(System.Net.WebSockets.WebSocketError error, string message) { }
+    public WebSocketException(System.Net.WebSockets.WebSocketError error, string message, System.Exception innerException) { }
+    public WebSocketException(string message) { }
+    public WebSocketException(string message, System.Exception innerException) { }
+    public System.Net.WebSockets.WebSocketError WebSocketErrorCode { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.WebSockets.WebSocketError); } }
+  }
+
+  public enum WebSocketMessageType {
+    Binary = 1,
+    Close = 2,
+    Text = 0,
+  }
+
+  public partial class WebSocketReceiveResult {
+    public WebSocketReceiveResult(int count, System.Net.WebSockets.WebSocketMessageType messageType, bool endOfMessage) { }
+    public WebSocketReceiveResult(int count, System.Net.WebSockets.WebSocketMessageType messageType, bool endOfMessage, System.Nullable<System.Net.WebSockets.WebSocketCloseStatus> closeStatus, string closeStatusDescription) { }
+    public System.Nullable<System.Net.WebSockets.WebSocketCloseStatus> CloseStatus { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Nullable<System.Net.WebSockets.WebSocketCloseStatus>); } }
+    public string CloseStatusDescription { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(string); } }
+    public int Count { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(int); } }
+    public bool EndOfMessage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(bool); } }
+    public System.Net.WebSockets.WebSocketMessageType MessageType { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.WebSockets.WebSocketMessageType); } }
+  }
+
+  public enum WebSocketState {
+    Aborted = 6,
+    Closed = 5,
+    CloseReceived = 4,
+    CloseSent = 3,
+    Connecting = 1,
+    None = 0,
+    Open = 2,
+  }
+
+} // end of System.Net.WebSockets

fxdac/fxdac/Data/Contracts/System.Net.cs

@@ -0,0 +1,363 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Net {
+  public partial class AuthenticationManager {
+    internal AuthenticationManager() { }
+    public static System.Net.ICredentialPolicy CredentialPolicy { get { return default(System.Net.ICredentialPolicy); } set { } }
+    public static System.Collections.Specialized.StringDictionary CustomTargetNameDictionary { get { return default(System.Collections.Specialized.StringDictionary); } }
+    public static System.Collections.IEnumerator RegisteredModules { get { return default(System.Collections.IEnumerator); } }
+    public static System.Net.Authorization Authenticate(string challenge, System.Net.WebRequest request, System.Net.ICredentials credentials) { return default(System.Net.Authorization); }
+    public static System.Net.Authorization PreAuthenticate(System.Net.WebRequest request, System.Net.ICredentials credentials) { return default(System.Net.Authorization); }
+    public static void Register(System.Net.IAuthenticationModule authenticationModule) { }
+    public static void Unregister(System.Net.IAuthenticationModule authenticationModule) { }
+    public static void Unregister(string authenticationScheme) { }
+  }
+
+  public partial class Authorization {
+    public Authorization(string token) { }
+    public Authorization(string token, bool finished) { }
+    public Authorization(string token, bool finished, string connectionGroupId) { }
+    public bool Complete { get { return default(bool); } }
+    public string ConnectionGroupId { get { return default(string); } }
+    public string Message { get { return default(string); } }
+    public bool MutuallyAuthenticated { get { return default(bool); } set { } }
+    public string[] ProtectionRealm { get { return default(string[]); } set { } }
+  }
+
+  public delegate System.Collections.Generic.IEnumerable<string> CipherSuitesCallback(System.Net.SecurityProtocolType protocol, System.Collections.Generic.IEnumerable<string> allCiphers);
+
+  public partial class EndpointPermission {
+    internal EndpointPermission() { }
+    public string Hostname { get { return default(string); } }
+    public int Port { get { return default(int); } }
+    public System.Net.TransportType Transport { get { return default(System.Net.TransportType); } }
+    public override bool Equals(object obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  public partial class FileWebRequest : System.Net.WebRequest, System.Runtime.Serialization.ISerializable {
+    [System.ObsoleteAttribute("Serialization is obsoleted for this type", false)]
+    protected FileWebRequest(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override string ConnectionGroupName { get { return default(string); } set { } }
+    public override long ContentLength { get { return default(long); } set { } }
+    public override string ContentType { get { return default(string); } set { } }
+    public override System.Net.ICredentials Credentials { get { return default(System.Net.ICredentials); } set { } }
+    public override System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } }
+    public override string Method { get { return default(string); } set { } }
+    public override bool PreAuthenticate { get { return default(bool); } set { } }
+    public override System.Net.IWebProxy Proxy { get { return default(System.Net.IWebProxy); } set { } }
+    public override System.Uri RequestUri { get { return default(System.Uri); } }
+    public override int Timeout { get { return default(int); } set { } }
+    public override bool UseDefaultCredentials { get { return default(bool); } set { } }
+    public override void Abort() { }
+    public override System.IAsyncResult BeginGetRequestStream(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginGetResponse(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public override System.IO.Stream EndGetRequestStream(System.IAsyncResult asyncResult) { return default(System.IO.Stream); }
+    public override System.Net.WebResponse EndGetResponse(System.IAsyncResult asyncResult) { return default(System.Net.WebResponse); }
+    protected override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override System.IO.Stream GetRequestStream() { return default(System.IO.Stream); }
+    public override System.Net.WebResponse GetResponse() { return default(System.Net.WebResponse); }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  public partial class FileWebResponse : System.Net.WebResponse, System.IDisposable, System.Runtime.Serialization.ISerializable {
+    [System.ObsoleteAttribute("Serialization is obsoleted for this type", false)]
+    protected FileWebResponse(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override long ContentLength { get { return default(long); } }
+    public override string ContentType { get { return default(string); } }
+    public override System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } }
+    public override System.Uri ResponseUri { get { return default(System.Uri); } }
+    public override void Close() { }
+    protected override void Dispose(bool disposing) { }
+    ~FileWebResponse() { }
+    protected override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public override System.IO.Stream GetResponseStream() { return default(System.IO.Stream); }
+    void System.IDisposable.Dispose() { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  public enum FtpStatusCode {
+    AccountNeeded = 532,
+    ActionAbortedLocalProcessingError = 451,
+    ActionAbortedUnknownPageType = 551,
+    ActionNotTakenFilenameNotAllowed = 553,
+    ActionNotTakenFileUnavailable = 550,
+    ActionNotTakenFileUnavailableOrBusy = 450,
+    ActionNotTakenInsufficientSpace = 452,
+    ArgumentSyntaxError = 501,
+    BadCommandSequence = 503,
+    CantOpenData = 425,
+    ClosingControl = 221,
+    ClosingData = 226,
+    CommandExtraneous = 202,
+    CommandNotImplemented = 502,
+    CommandOK = 200,
+    CommandSyntaxError = 500,
+    ConnectionClosed = 426,
+    DataAlreadyOpen = 125,
+    DirectoryStatus = 212,
+    EnteringPassive = 227,
+    FileActionAborted = 552,
+    FileActionOK = 250,
+    FileCommandPending = 350,
+    FileStatus = 213,
+    LoggedInProceed = 230,
+    NeedLoginAccount = 332,
+    NotLoggedIn = 530,
+    OpeningData = 150,
+    PathnameCreated = 257,
+    RestartMarker = 110,
+    SendPasswordCommand = 331,
+    SendUserCommand = 220,
+    ServerWantsSecureSession = 234,
+    ServiceNotAvailable = 421,
+    ServiceTemporarilyNotAvailable = 120,
+    SystemType = 215,
+    Undefined = 0,
+  }
+
+  public sealed partial class FtpWebRequest : System.Net.WebRequest {
+    internal FtpWebRequest() { }
+    public System.Security.Cryptography.X509Certificates.X509CertificateCollection ClientCertificates { get { return default(System.Security.Cryptography.X509Certificates.X509CertificateCollection); } set { } }
+    public override string ConnectionGroupName { get { return default(string); } set { } }
+    public override long ContentLength { get { return default(long); } set { } }
+    public long ContentOffset { get { return default(long); } set { } }
+    public override string ContentType { get { return default(string); } set { } }
+    public override System.Net.ICredentials Credentials { get { return default(System.Net.ICredentials); } set { } }
+    public bool EnableSsl { get { return default(bool); } set { } }
+    public override System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } set { } }
+    public bool KeepAlive { get { return default(bool); } set { } }
+    public override string Method { get { return default(string); } set { } }
+    public override bool PreAuthenticate { get { return default(bool); } set { } }
+    public override System.Net.IWebProxy Proxy { get { return default(System.Net.IWebProxy); } set { } }
+    public int ReadWriteTimeout { get { return default(int); } set { } }
+    public string RenameTo { get { return default(string); } set { } }
+    public override System.Uri RequestUri { get { return default(System.Uri); } }
+    public System.Net.ServicePoint ServicePoint { get { return default(System.Net.ServicePoint); } }
+    public override int Timeout { get { return default(int); } set { } }
+    public bool UseBinary { get { return default(bool); } set { } }
+    public override bool UseDefaultCredentials { get { return default(bool); } set { } }
+    public bool UsePassive { get { return default(bool); } set { } }
+    public override void Abort() { }
+    public override System.IAsyncResult BeginGetRequestStream(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginGetResponse(System.AsyncCallback callback, object state) { return default(System.IAsyncResult); }
+    public override System.IO.Stream EndGetRequestStream(System.IAsyncResult asyncResult) { return default(System.IO.Stream); }
+    public override System.Net.WebResponse EndGetResponse(System.IAsyncResult asyncResult) { return default(System.Net.WebResponse); }
+    public override System.IO.Stream GetRequestStream() { return default(System.IO.Stream); }
+    public override System.Net.WebResponse GetResponse() { return default(System.Net.WebResponse); }
+  }
+
+  public partial class FtpWebResponse : System.Net.WebResponse {
+    internal FtpWebResponse() { }
+    public string BannerMessage { get { return default(string); } }
+    public override long ContentLength { get { return default(long); } }
+    public string ExitMessage { get { return default(string); } }
+    public override System.Net.WebHeaderCollection Headers { get { return default(System.Net.WebHeaderCollection); } }
+    public System.DateTime LastModified { get { return default(System.DateTime); } }
+    public override System.Uri ResponseUri { get { return default(System.Uri); } }
+    public System.Net.FtpStatusCode StatusCode { get { return default(System.Net.FtpStatusCode); } }
+    public string StatusDescription { get { return default(string); } }
+    public string WelcomeMessage { get { return default(string); } }
+    public override void Close() { }
+    public override System.IO.Stream GetResponseStream() { return default(System.IO.Stream); }
+  }
+
+  [System.ObsoleteAttribute("Use WebRequest.DefaultProxy instead")]
+  public partial class GlobalProxySelection {
+    public GlobalProxySelection() { }
+    public static System.Net.IWebProxy Select { get { return default(System.Net.IWebProxy); } set { } }
+    public static System.Net.IWebProxy GetEmptyWebProxy() { return default(System.Net.IWebProxy); }
+  }
+
+  public partial class HttpVersion {
+    public static readonly System.Version Version10;
+    public static readonly System.Version Version11;
+    public HttpVersion() { }
+  }
+
+  public partial interface IAuthenticationModule {
+    string AuthenticationType { get; }
+    bool CanPreAuthenticate { get; }
+    System.Net.Authorization Authenticate(string challenge, System.Net.WebRequest request, System.Net.ICredentials credentials);
+    System.Net.Authorization PreAuthenticate(System.Net.WebRequest request, System.Net.ICredentials credentials);
+  }
+
+  public partial interface ICertificatePolicy {
+    bool CheckValidationResult(System.Net.ServicePoint srvPoint, System.Security.Cryptography.X509Certificates.X509Certificate certificate, System.Net.WebRequest request, int certificateProblem);
+  }
+
+  public partial interface ICredentialPolicy {
+    bool ShouldSendCredential(System.Uri challengeUri, System.Net.WebRequest request, System.Net.NetworkCredential credential, System.Net.IAuthenticationModule authenticationModule);
+  }
+
+  public partial interface IWebProxyScript {
+    void Close();
+    bool Load(System.Uri scriptLocation, string script, System.Type helperType);
+    string Run(string url, string host);
+  }
+
+  [System.FlagsAttribute]
+  public enum NetworkAccess {
+    Accept = 128,
+    Connect = 64,
+  }
+
+  [System.FlagsAttribute]
+  public enum SecurityProtocolType {
+    Ssl3 = 48,
+    Tls = 192,
+  }
+
+  public partial class ServicePointManager {
+    internal ServicePointManager() { }
+    public const int DefaultNonPersistentConnectionLimit = 4;
+    public const int DefaultPersistentConnectionLimit = 10;
+    [System.ObsoleteAttribute("Use ServerCertificateValidationCallback instead", false)]
+    public static System.Net.ICertificatePolicy CertificatePolicy { get { return default(System.Net.ICertificatePolicy); } set { } }
+    public static bool CheckCertificateRevocationList { get { return default(bool); } set { } }
+    public static System.Net.CipherSuitesCallback ClientCipherSuitesCallback { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.CipherSuitesCallback); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public static int DefaultConnectionLimit { get { return default(int); } set { } }
+    public static int DnsRefreshTimeout { get { return default(int); } set { } }
+    public static bool EnableDnsRoundRobin { get { return default(bool); } set { } }
+    public static bool Expect100Continue { get { return default(bool); } set { } }
+    public static int MaxServicePointIdleTime { get { return default(int); } set { } }
+    public static int MaxServicePoints { get { return default(int); } set { } }
+    public static System.Net.SecurityProtocolType SecurityProtocol { get { return default(System.Net.SecurityProtocolType); } set { } }
+    public static System.Net.Security.RemoteCertificateValidationCallback ServerCertificateValidationCallback { get { return default(System.Net.Security.RemoteCertificateValidationCallback); } set { } }
+    public static System.Net.CipherSuitesCallback ServerCipherSuitesCallback { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { return default(System.Net.CipherSuitesCallback); } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+    public static bool UseNagleAlgorithm { get { return default(bool); } set { } }
+    public static System.Net.ServicePoint FindServicePoint(string uriString, System.Net.IWebProxy proxy) { return default(System.Net.ServicePoint); }
+    public static System.Net.ServicePoint FindServicePoint(System.Uri address) { return default(System.Net.ServicePoint); }
+    public static System.Net.ServicePoint FindServicePoint(System.Uri address, System.Net.IWebProxy proxy) { return default(System.Net.ServicePoint); }
+    public static void SetTcpKeepAlive(bool enabled, int keepAliveTime, int keepAliveInterval) { }
+  }
+
+  public sealed partial class SocketPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public const int AllPorts = -1;
+    public SocketPermission(System.Net.NetworkAccess access, System.Net.TransportType transport, string hostName, int portNumber) { }
+    public SocketPermission(System.Security.Permissions.PermissionState state) { }
+    public System.Collections.IEnumerator AcceptList { get { return default(System.Collections.IEnumerator); } }
+    public System.Collections.IEnumerator ConnectList { get { return default(System.Collections.IEnumerator); } }
+    public void AddPermission(System.Net.NetworkAccess access, System.Net.TransportType transport, string hostName, int portNumber) { }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement securityElement) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  public sealed partial class SocketPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public SocketPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public string Access { get { return default(string); } set { } }
+    public string Host { get { return default(string); } set { } }
+    public string Port { get { return default(string); } set { } }
+    public string Transport { get { return default(string); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  public enum TransportType {
+    All = 3,
+    Connectionless = 1,
+    ConnectionOriented = 2,
+    Tcp = 2,
+    Udp = 1,
+  }
+
+  public partial class WebProxy : System.Net.IWebProxy, System.Runtime.Serialization.ISerializable {
+    public WebProxy() { }
+    protected WebProxy(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public WebProxy(string address) { }
+    public WebProxy(string address, bool bypassOnLocal) { }
+    public WebProxy(string address, bool bypassOnLocal, string[] bypassList) { }
+    public WebProxy(string address, bool bypassOnLocal, string[] bypassList, System.Net.ICredentials credentials) { }
+    public WebProxy(string host, int port) { }
+    public WebProxy(System.Uri address) { }
+    public WebProxy(System.Uri address, bool bypassOnLocal) { }
+    public WebProxy(System.Uri address, bool bypassOnLocal, string[] bypassList) { }
+    public WebProxy(System.Uri address, bool bypassOnLocal, string[] bypassList, System.Net.ICredentials credentials) { }
+    public System.Uri Address { get { return default(System.Uri); } set { } }
+    public System.Collections.ArrayList BypassArrayList { get { return default(System.Collections.ArrayList); } }
+    public string[] BypassList { get { return default(string[]); } set { } }
+    public bool BypassProxyOnLocal { get { return default(bool); } set { } }
+    public System.Net.ICredentials Credentials { get { return default(System.Net.ICredentials); } set { } }
+    public bool UseDefaultCredentials { get { return default(bool); } set { } }
+    [System.ObsoleteAttribute("This method has been deprecated", false)]
+    public static System.Net.WebProxy GetDefaultProxy() { return default(System.Net.WebProxy); }
+    protected virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+    public System.Uri GetProxy(System.Uri destination) { return default(System.Uri); }
+    public bool IsBypassed(System.Uri host) { return default(bool); }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  public static partial class WebRequestMethods {
+    public static partial class File {
+      public const string DownloadFile = "GET";
+      public const string UploadFile = "PUT";
+    }
+    public static partial class Ftp {
+      public const string AppendFile = "APPE";
+      public const string DeleteFile = "DELE";
+      public const string DownloadFile = "RETR";
+      public const string GetDateTimestamp = "MDTM";
+      public const string GetFileSize = "SIZE";
+      public const string ListDirectory = "NLST";
+      public const string ListDirectoryDetails = "LIST";
+      public const string MakeDirectory = "MKD";
+      public const string PrintWorkingDirectory = "PWD";
+      public const string RemoveDirectory = "RMD";
+      public const string Rename = "RENAME";
+      public const string UploadFile = "STOR";
+      public const string UploadFileWithUniqueName = "STOU";
+    }
+    public static partial class Http {
+      public const string Connect = "CONNECT";
+      public const string Get = "GET";
+      public const string Head = "HEAD";
+      public const string MkCol = "MKCOL";
+      public const string Post = "POST";
+      public const string Put = "PUT";
+    }
+  }
+
+} // end of System.Net
+namespace System.Net.Cache {
+  public enum HttpCacheAgeControl {
+    MaxAge = 2,
+    MaxAgeAndMaxStale = 6,
+    MaxAgeAndMinFresh = 3,
+    MaxStale = 4,
+    MinFresh = 1,
+    None = 0,
+  }
+
+  public enum HttpRequestCacheLevel {
+    BypassCache = 1,
+    CacheIfAvailable = 3,
+    CacheOnly = 2,
+    CacheOrNextCacheOnly = 7,
+    Default = 0,
+    NoCacheNoStore = 6,
+    Refresh = 8,
+    Reload = 5,
+    Revalidate = 4,
+  }
+
+  public partial class HttpRequestCachePolicy : System.Net.Cache.RequestCachePolicy {
+    public HttpRequestCachePolicy() { }
+    public HttpRequestCachePolicy(System.DateTime cacheSyncDate) { }
+    public HttpRequestCachePolicy(System.Net.Cache.HttpCacheAgeControl cacheAgeControl, System.TimeSpan ageOrFreshOrStale) { }
+    public HttpRequestCachePolicy(System.Net.Cache.HttpCacheAgeControl cacheAgeControl, System.TimeSpan maxAge, System.TimeSpan freshOrStale) { }
+    public HttpRequestCachePolicy(System.Net.Cache.HttpCacheAgeControl cacheAgeControl, System.TimeSpan maxAge, System.TimeSpan freshOrStale, System.DateTime cacheSyncDate) { }
+    public HttpRequestCachePolicy(System.Net.Cache.HttpRequestCacheLevel level) { }
+    public System.DateTime CacheSyncDate { get { return default(System.DateTime); } }
+    public new System.Net.Cache.HttpRequestCacheLevel Level { get { return default(System.Net.Cache.HttpRequestCacheLevel); } }
+    public System.TimeSpan MaxAge { get { return default(System.TimeSpan); } }
+    public System.TimeSpan MaxStale { get { return default(System.TimeSpan); } }
+    public System.TimeSpan MinFresh { get { return default(System.TimeSpan); } }
+    public override string ToString() { return default(string); }
+  }
+
+} // end of System.Net.Cache

fxdac/fxdac/Data/Contracts/System.ObjectModel.cs

@@ -0,0 +1,197 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Collections.ObjectModel {
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public abstract partial class KeyedCollection<TKey, TItem> : System.Collections.ObjectModel.Collection<TItem> {
+    protected KeyedCollection() { }
+    protected KeyedCollection(System.Collections.Generic.IEqualityComparer<TKey> comparer) { }
+    protected KeyedCollection(System.Collections.Generic.IEqualityComparer<TKey> comparer, int dictionaryCreationThreshold) { }
+    public System.Collections.Generic.IEqualityComparer<TKey> Comparer { get { return default(System.Collections.Generic.IEqualityComparer<TKey>); } }
+    protected System.Collections.Generic.IDictionary<TKey, TItem> Dictionary { get { return default(System.Collections.Generic.IDictionary<TKey, TItem>); } }
+    public TItem this[TKey key] { get { return default(TItem); } }
+    protected void ChangeItemKey(TItem item, TKey newKey) { }
+    protected override void ClearItems() { }
+    public bool Contains(TKey key) { return default(bool); }
+    protected abstract TKey GetKeyForItem(TItem item);
+    protected override void InsertItem(int index, TItem item) { }
+    public bool Remove(TKey key) { return default(bool); }
+    protected override void RemoveItem(int index) { }
+    protected override void SetItem(int index, TItem item) { }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+  public partial class ReadOnlyDictionary<TKey, TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IDictionary<TKey, TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>, System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable {
+    public ReadOnlyDictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary) { }
+    public int Count { get { return default(int); } }
+    protected System.Collections.Generic.IDictionary<TKey, TValue> Dictionary { get { return default(System.Collections.Generic.IDictionary<TKey, TValue>); } }
+    public TValue this[TKey key] { get { return default(TValue); } }
+    public System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue>.KeyCollection Keys { get { return default(System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue>.KeyCollection); } }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get { return default(bool); } }
+    TValue System.Collections.Generic.IDictionary<TKey,TValue>.this[TKey key] { get { return default(TValue); } set { } }
+    System.Collections.Generic.ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get { return default(System.Collections.Generic.ICollection<TKey>); } }
+    System.Collections.Generic.ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get { return default(System.Collections.Generic.ICollection<TValue>); } }
+    System.Collections.Generic.IEnumerable<TKey> System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>.Keys { get { return default(System.Collections.Generic.IEnumerable<TKey>); } }
+    System.Collections.Generic.IEnumerable<TValue> System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>.Values { get { return default(System.Collections.Generic.IEnumerable<TValue>); } }
+    bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+    object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+    bool System.Collections.IDictionary.IsFixedSize { get { return default(bool); } }
+    bool System.Collections.IDictionary.IsReadOnly { get { return default(bool); } }
+    object System.Collections.IDictionary.this[object key] { get { return default(object); } set { } }
+    System.Collections.ICollection System.Collections.IDictionary.Keys { get { return default(System.Collections.ICollection); } }
+    System.Collections.ICollection System.Collections.IDictionary.Values { get { return default(System.Collections.ICollection); } }
+    public System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue>.ValueCollection Values { get { return default(System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue>.ValueCollection); } }
+    public bool ContainsKey(TKey key) { return default(bool); }
+    public System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>); }
+    void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(System.Collections.Generic.KeyValuePair<TKey, TValue> item) { }
+    void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Clear() { }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Contains(System.Collections.Generic.KeyValuePair<TKey, TValue> item) { return default(bool); }
+    void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(System.Collections.Generic.KeyValuePair<TKey, TValue>[] array, int arrayIndex) { }
+    bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(System.Collections.Generic.KeyValuePair<TKey, TValue> item) { return default(bool); }
+    void System.Collections.Generic.IDictionary<TKey,TValue>.Add(TKey key, TValue value) { }
+    bool System.Collections.Generic.IDictionary<TKey,TValue>.Remove(TKey key) { return default(bool); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    void System.Collections.IDictionary.Add(object key, object value) { }
+    void System.Collections.IDictionary.Clear() { }
+    bool System.Collections.IDictionary.Contains(object key) { return default(bool); }
+    System.Collections.IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    void System.Collections.IDictionary.Remove(object key) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public bool TryGetValue(TKey key, out TValue value) { value = default(TValue); return default(bool); }
+    [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+    public sealed partial class KeyCollection : System.Collections.Generic.ICollection<TKey>, System.Collections.Generic.IEnumerable<TKey>, System.Collections.ICollection, System.Collections.IEnumerable {
+      internal KeyCollection() { }
+      public int Count { get { return default(int); } }
+      bool System.Collections.Generic.ICollection<TKey>.IsReadOnly { get { return default(bool); } }
+      bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+      object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+      public void CopyTo(TKey[] array, int arrayIndex) { }
+      public System.Collections.Generic.IEnumerator<TKey> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<TKey>); }
+      void System.Collections.Generic.ICollection<TKey>.Add(TKey item) { }
+      void System.Collections.Generic.ICollection<TKey>.Clear() { }
+      bool System.Collections.Generic.ICollection<TKey>.Contains(TKey item) { return default(bool); }
+      bool System.Collections.Generic.ICollection<TKey>.Remove(TKey item) { return default(bool); }
+      void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+      System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    }
+    [System.Diagnostics.DebuggerDisplayAttribute("Count = {Count}")]
+    public sealed partial class ValueCollection : System.Collections.Generic.ICollection<TValue>, System.Collections.Generic.IEnumerable<TValue>, System.Collections.ICollection, System.Collections.IEnumerable {
+      internal ValueCollection() { }
+      public int Count { get { return default(int); } }
+      bool System.Collections.Generic.ICollection<TValue>.IsReadOnly { get { return default(bool); } }
+      bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
+      object System.Collections.ICollection.SyncRoot { get { return default(object); } }
+      public void CopyTo(TValue[] array, int arrayIndex) { }
+      public System.Collections.Generic.IEnumerator<TValue> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<TValue>); }
+      void System.Collections.Generic.ICollection<TValue>.Add(TValue item) { }
+      void System.Collections.Generic.ICollection<TValue>.Clear() { }
+      bool System.Collections.Generic.ICollection<TValue>.Contains(TValue item) { return default(bool); }
+      bool System.Collections.Generic.ICollection<TValue>.Remove(TValue item) { return default(bool); }
+      void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+      System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    }
+  }
+
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+  public partial class ObservableCollection<T> : System.Collections.ObjectModel.Collection<T>, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged {
+    public ObservableCollection() { }
+    public ObservableCollection(System.Collections.Generic.IEnumerable<T> collection) { }
+    public ObservableCollection(System.Collections.Generic.List<T> list) { }
+    public virtual event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanged { add { } remove { } }
+    protected virtual event System.ComponentModel.PropertyChangedEventHandler PropertyChanged { add { } remove { } }
+    event System.ComponentModel.PropertyChangedEventHandler System.ComponentModel.INotifyPropertyChanged.PropertyChanged { add { } remove { } }
+    protected System.IDisposable BlockReentrancy() { return default(System.IDisposable); }
+    protected void CheckReentrancy() { }
+    protected override void ClearItems() { }
+    protected override void InsertItem(int index, T item) { }
+    public void Move(int oldIndex, int newIndex) { }
+    protected virtual void MoveItem(int oldIndex, int newIndex) { }
+    protected virtual void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e) { }
+    protected virtual void OnPropertyChanged(System.ComponentModel.PropertyChangedEventArgs e) { }
+    protected override void RemoveItem(int index) { }
+    protected override void SetItem(int index, T item) { }
+  }
+
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+  public partial class ReadOnlyObservableCollection<T> : System.Collections.ObjectModel.ReadOnlyCollection<T>, System.Collections.Specialized.INotifyCollectionChanged, System.ComponentModel.INotifyPropertyChanged {
+    public ReadOnlyObservableCollection(System.Collections.ObjectModel.ObservableCollection<T> list) : base (default(System.Collections.Generic.IList<T>)) { }
+    protected virtual event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanged { add { } remove { } }
+    protected virtual event System.ComponentModel.PropertyChangedEventHandler PropertyChanged { add { } remove { } }
+    event System.Collections.Specialized.NotifyCollectionChangedEventHandler System.Collections.Specialized.INotifyCollectionChanged.CollectionChanged { add { } remove { } }
+    event System.ComponentModel.PropertyChangedEventHandler System.ComponentModel.INotifyPropertyChanged.PropertyChanged { add { } remove { } }
+    protected virtual void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs args) { }
+    protected virtual void OnPropertyChanged(System.ComponentModel.PropertyChangedEventArgs args) { }
+  }
+
+} // end of System.Collections.ObjectModel
+namespace System.Collections.Specialized {
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+  public partial interface INotifyCollectionChanged {
+    event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanged;
+  }
+
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+  public enum NotifyCollectionChangedAction {
+    Add = 0,
+    Move = 3,
+    Remove = 1,
+    Replace = 2,
+    Reset = 4,
+  }
+
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+  public partial class NotifyCollectionChangedEventArgs : System.EventArgs {
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, System.Collections.IList changedItems) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, System.Collections.IList newItems, System.Collections.IList oldItems) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, System.Collections.IList newItems, System.Collections.IList oldItems, int startingIndex) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, System.Collections.IList changedItems, int startingIndex) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, System.Collections.IList changedItems, int index, int oldIndex) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, object changedItem) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, object changedItem, int index) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, object changedItem, int index, int oldIndex) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, object newItem, object oldItem) { }
+    public NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction action, object newItem, object oldItem, int index) { }
+    public System.Collections.Specialized.NotifyCollectionChangedAction Action { get { return default(System.Collections.Specialized.NotifyCollectionChangedAction); } }
+    public System.Collections.IList NewItems { get { return default(System.Collections.IList); } }
+    public int NewStartingIndex { get { return default(int); } }
+    public System.Collections.IList OldItems { get { return default(System.Collections.IList); } }
+    public int OldStartingIndex { get { return default(int); } }
+  }
+
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
+  public delegate void NotifyCollectionChangedEventHandler(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e);
+
+} // end of System.Collections.Specialized
+namespace System.ComponentModel {
+  public partial interface INotifyPropertyChanged {
+    event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
+  }
+
+  public partial interface INotifyPropertyChanging {
+    event System.ComponentModel.PropertyChangingEventHandler PropertyChanging;
+  }
+
+  public partial class PropertyChangedEventArgs : System.EventArgs {
+    public PropertyChangedEventArgs(string propertyName) { }
+    public virtual string PropertyName { get { return default(string); } }
+  }
+
+  public delegate void PropertyChangedEventHandler(object sender, System.ComponentModel.PropertyChangedEventArgs e);
+
+  public partial class PropertyChangingEventArgs : System.EventArgs {
+    public PropertyChangingEventArgs(string propertyName) { }
+    public virtual string PropertyName { get { return default(string); } }
+  }
+
+  public delegate void PropertyChangingEventHandler(object sender, System.ComponentModel.PropertyChangingEventArgs e);
+
+} // end of System.ComponentModel
+namespace System.Windows.Input {
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("PresentationCore, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
+  public partial interface ICommand {
+    event System.EventHandler CanExecuteChanged;
+    bool CanExecute(object parameter);
+    void Execute(object parameter);
+  }
+
+} // end of System.Windows.Input

fxdac/fxdac/Data/Contracts/System.Resources.Reader.cs

@@ -0,0 +1,22 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Resources {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface IResourceReader : System.Collections.IEnumerable, System.IDisposable {
+    void Close();
+    new System.Collections.IDictionaryEnumerator GetEnumerator();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ResourceReader : System.Collections.IEnumerable, System.IDisposable, System.Resources.IResourceReader {
+    [System.Security.SecurityCriticalAttribute]
+    public ResourceReader(System.IO.Stream stream) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public ResourceReader(string fileName) { }
+    public void Close() { }
+    public void Dispose() { }
+    public System.Collections.IDictionaryEnumerator GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    public void GetResourceData(string resourceName, out string resourceType, out byte[] resourceData) { resourceType = default(string); resourceData = default(byte[]); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+} // end of System.Resources

fxdac/fxdac/Data/Contracts/System.Resources.ResourceManager.cs

@@ -0,0 +1,103 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Resources {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class MissingManifestResourceException : System.SystemException {
+    public MissingManifestResourceException() { }
+    protected MissingManifestResourceException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public MissingManifestResourceException(string message) { }
+    public MissingManifestResourceException(string message, System.Exception inner) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class MissingSatelliteAssemblyException : System.SystemException {
+    public MissingSatelliteAssemblyException() { }
+    protected MissingSatelliteAssemblyException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public MissingSatelliteAssemblyException(string message) { }
+    public MissingSatelliteAssemblyException(string message, System.Exception inner) { }
+    public MissingSatelliteAssemblyException(string message, string cultureName) { }
+    public string CultureName { get { return default(string); } }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(1), AllowMultiple=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class NeutralResourcesLanguageAttribute : System.Attribute {
+    public NeutralResourcesLanguageAttribute(string cultureName) { }
+    public NeutralResourcesLanguageAttribute(string cultureName, System.Resources.UltimateResourceFallbackLocation location) { }
+    public string CultureName { get { return default(string); } }
+    public System.Resources.UltimateResourceFallbackLocation Location { get { return default(System.Resources.UltimateResourceFallbackLocation); } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ResourceManager {
+    protected string BaseNameField;
+    public static readonly int HeaderVersionNumber;
+    public static readonly int MagicNumber;
+    protected System.Reflection.Assembly MainAssembly;
+    [System.ObsoleteAttribute("call InternalGetResourceSet instead")]
+    protected System.Collections.Hashtable ResourceSets;
+    protected ResourceManager() { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]public ResourceManager(string baseName, System.Reflection.Assembly assembly) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]public ResourceManager(string baseName, System.Reflection.Assembly assembly, System.Type usingResourceSet) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]public ResourceManager(System.Type resourceSource) { }
+    public virtual string BaseName { get { return default(string); } }
+    protected System.Resources.UltimateResourceFallbackLocation FallbackLocation { get { return default(System.Resources.UltimateResourceFallbackLocation); } set { } }
+    public virtual bool IgnoreCase { get { return default(bool); } set { } }
+    public virtual System.Type ResourceSetType { get { return default(System.Type); } }
+    public static System.Resources.ResourceManager CreateFileBasedResourceManager(string baseName, string resourceDir, System.Type usingResourceSet) { return default(System.Resources.ResourceManager); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected static System.Globalization.CultureInfo GetNeutralResourcesLanguage(System.Reflection.Assembly a) { return default(System.Globalization.CultureInfo); }
+    public virtual object GetObject(string name) { return default(object); }
+    public virtual object GetObject(string name, System.Globalization.CultureInfo culture) { return default(object); }
+    protected virtual string GetResourceFileName(System.Globalization.CultureInfo culture) { return default(string); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecuritySafeCriticalAttribute]
+    public virtual System.Resources.ResourceSet GetResourceSet(System.Globalization.CultureInfo culture, bool createIfNotExists, bool tryParents) { return default(System.Resources.ResourceSet); }
+    protected static System.Version GetSatelliteContractVersion(System.Reflection.Assembly a) { return default(System.Version); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.IO.UnmanagedMemoryStream GetStream(string name) { return default(System.IO.UnmanagedMemoryStream); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.IO.UnmanagedMemoryStream GetStream(string name, System.Globalization.CultureInfo culture) { return default(System.IO.UnmanagedMemoryStream); }
+    public virtual string GetString(string name) { return default(string); }
+    public virtual string GetString(string name, System.Globalization.CultureInfo culture) { return default(string); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecuritySafeCriticalAttribute]
+    protected virtual System.Resources.ResourceSet InternalGetResourceSet(System.Globalization.CultureInfo culture, bool createIfNotExists, bool tryParents) { return default(System.Resources.ResourceSet); }
+    public virtual void ReleaseAllResources() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ResourceSet : System.Collections.IEnumerable, System.IDisposable {
+    protected System.Resources.IResourceReader Reader;
+    protected System.Collections.Hashtable Table;
+    protected ResourceSet() { }
+    [System.Security.SecurityCriticalAttribute]
+    public ResourceSet(System.IO.Stream stream) { }
+    public ResourceSet(System.Resources.IResourceReader reader) { }
+    public ResourceSet(string fileName) { }
+    public virtual void Close() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public virtual System.Type GetDefaultReader() { return default(System.Type); }
+    public virtual System.Type GetDefaultWriter() { return default(System.Type); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual System.Collections.IDictionaryEnumerator GetEnumerator() { return default(System.Collections.IDictionaryEnumerator); }
+    public virtual object GetObject(string name) { return default(object); }
+    public virtual object GetObject(string name, bool ignoreCase) { return default(object); }
+    public virtual string GetString(string name) { return default(string); }
+    public virtual string GetString(string name, bool ignoreCase) { return default(string); }
+    protected virtual void ReadResources() { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(1), AllowMultiple=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class SatelliteContractVersionAttribute : System.Attribute {
+    public SatelliteContractVersionAttribute(string version) { }
+    public string Version { get { return default(string); } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum UltimateResourceFallbackLocation {
+    MainAssembly = 0,
+    Satellite = 1,
+  }
+
+} // end of System.Resources

fxdac/fxdac/Data/Contracts/System.Resources.Writer.cs

@@ -0,0 +1,29 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Resources {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface IResourceWriter : System.IDisposable {
+    void AddResource(string name, byte[] value);
+    void AddResource(string name, object value);
+    void AddResource(string name, string value);
+    void Close();
+    void Generate();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ResourceWriter : System.IDisposable, System.Resources.IResourceWriter {
+    public ResourceWriter(System.IO.Stream stream) { }
+    public ResourceWriter(string fileName) { }
+    public System.Func<System.Type, string> TypeNameConverter { get { return default(System.Func<System.Type, string>); } set { } }
+    public void AddResource(string name, byte[] value) { }
+    public void AddResource(string name, System.IO.Stream value) { }
+    public void AddResource(string name, System.IO.Stream value, bool closeAfterWrite) { }
+    public void AddResource(string name, object value) { }
+    public void AddResource(string name, string value) { }
+    public void AddResourceData(string name, string typeName, byte[] serializedData) { }
+    public void Close() { }
+    public void Dispose() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Generate() { }
+  }
+
+} // end of System.Resources

fxdac/fxdac/Data/Contracts/System.Runtime.ConstrainedExecution.cs

@@ -0,0 +1,8 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Runtime.ConstrainedExecution {
+  [System.AttributeUsageAttribute((System.AttributeTargets)(96), Inherited=false)]
+  public sealed partial class PrePrepareMethodAttribute : System.Attribute {
+    public PrePrepareMethodAttribute() { }
+  }
+
+} // end of System.Runtime.ConstrainedExecution

fxdac/fxdac/Data/Contracts/System.Runtime.Extensions.cs

@@ -0,0 +1,32 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Diagnostics {
+  public partial class Stopwatch {
+    public static readonly long Frequency;
+    public static readonly bool IsHighResolution;
+    public Stopwatch() { }
+    public System.TimeSpan Elapsed { get { return default(System.TimeSpan); } }
+    public long ElapsedMilliseconds { get { return default(long); } }
+    public long ElapsedTicks { get { return default(long); } }
+    public bool IsRunning { get { return default(bool); } }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static long GetTimestamp() { return default(long); }
+    public void Reset() { }
+    public void Restart() { }
+    public void Start() { }
+    public static System.Diagnostics.Stopwatch StartNew() { return default(System.Diagnostics.Stopwatch); }
+    public void Stop() { }
+  }
+
+} // end of System.Diagnostics
+namespace System.Net {
+  public static partial class WebUtility {
+    public static string HtmlDecode(string value) { return default(string); }
+    public static void HtmlDecode(string value, System.IO.TextWriter output) { }
+    public static string HtmlEncode(string value) { return default(string); }
+    public static void HtmlEncode(string value, System.IO.TextWriter output) { }
+    public static string UrlDecode(string encodedValue) { return default(string); }
+    public static byte[] UrlDecodeToBytes(byte[] encodedValue, int offset, int count) { return default(byte[]); }
+    public static string UrlEncode(string value) { return default(string); }
+    public static byte[] UrlEncodeToBytes(byte[] value, int offset, int count) { return default(byte[]); }
+  }
+
+} // end of System.Net

fxdac/fxdac/Data/Contracts/System.Runtime.Handles.cs

@@ -0,0 +1,31 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Runtime.InteropServices {
+  public abstract partial class CriticalHandle : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, System.IDisposable {
+    protected System.IntPtr handle;
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    protected CriticalHandle(System.IntPtr invalidHandleValue) { }
+    public bool IsClosed { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]get { return default(bool); } }
+    public abstract bool IsInvalid { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]get; }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public void Close() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public void Dispose() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    protected virtual void Dispose(bool disposing) { }
+    ~CriticalHandle() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    protected abstract bool ReleaseHandle();
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    protected void SetHandle(System.IntPtr handle) { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public void SetHandleAsInvalid() { }
+  }
+
+} // end of System.Runtime.InteropServices
+namespace System.IO {
+  public enum HandleInheritability {
+    Inheritable = 1,
+    None = 0,
+  }
+
+} // end of System.IO

fxdac/fxdac/Data/Contracts/System.Runtime.IsolatedStorage.cs

@@ -0,0 +1,234 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.IO.IsolatedStorage {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface INormalizeForIsolatedStorage {
+    object Normalize();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class IsolatedStorage {
+    protected IsolatedStorage() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public object ApplicationIdentity { get { return default(object); } }
+    public object AssemblyIdentity { get { return default(object); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual long AvailableFreeSpace { get { return default(long); } }
+    [System.CLSCompliantAttribute(false)]
+    [System.ObsoleteAttribute]
+    public virtual ulong CurrentSize { get { return default(ulong); } }
+    public object DomainIdentity { get { return default(object); } }
+    [System.CLSCompliantAttribute(false)]
+    [System.ObsoleteAttribute]
+    public virtual ulong MaximumSize { get { return default(ulong); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual long Quota { get { return default(long); } }
+    public System.IO.IsolatedStorage.IsolatedStorageScope Scope { get { return default(System.IO.IsolatedStorage.IsolatedStorageScope); } }
+    protected virtual char SeparatorExternal { get { return default(char); } }
+    protected virtual char SeparatorInternal { get { return default(char); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual long UsedSize { get { return default(long); } }
+    protected abstract System.Security.Permissions.IsolatedStoragePermission GetPermission(System.Security.PermissionSet ps);
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual bool IncreaseQuotaTo(long newQuotaSize) { return default(bool); }
+    protected void InitStore(System.IO.IsolatedStorage.IsolatedStorageScope scope, System.Type appEvidenceType) { }
+    protected void InitStore(System.IO.IsolatedStorage.IsolatedStorageScope scope, System.Type domainEvidenceType, System.Type assemblyEvidenceType) { }
+    public abstract void Remove();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class IsolatedStorageException : System.Exception {
+    public IsolatedStorageException() { }
+    protected IsolatedStorageException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public IsolatedStorageException(string message) { }
+    public IsolatedStorageException(string message, System.Exception inner) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class IsolatedStorageFile : System.IO.IsolatedStorage.IsolatedStorage, System.IDisposable {
+    internal IsolatedStorageFile() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override long AvailableFreeSpace { get { return default(long); } }
+    [System.CLSCompliantAttribute(false)]
+    [System.ObsoleteAttribute]
+    public override ulong CurrentSize { get { return default(ulong); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public static bool IsEnabled { get { return default(bool); } }
+    [System.CLSCompliantAttribute(false)]
+    [System.ObsoleteAttribute]
+    public override ulong MaximumSize { get { return default(ulong); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override long Quota { get { return default(long); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override long UsedSize { get { return default(long); } }
+    public void Close() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void CopyFile(string sourceFileName, string destinationFileName) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void CopyFile(string sourceFileName, string destinationFileName, bool overwrite) { }
+    public void CreateDirectory(string dir) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.IO.IsolatedStorage.IsolatedStorageFileStream CreateFile(string path) { return default(System.IO.IsolatedStorage.IsolatedStorageFileStream); }
+    public void DeleteDirectory(string dir) { }
+    public void DeleteFile(string file) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public bool DirectoryExists(string path) { return default(bool); }
+    public void Dispose() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public bool FileExists(string path) { return default(bool); }
+    ~IsolatedStorageFile() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.DateTimeOffset GetCreationTime(string path) { return default(System.DateTimeOffset); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public string[] GetDirectoryNames() { return default(string[]); }
+    public string[] GetDirectoryNames(string searchPattern) { return default(string[]); }
+    public static System.Collections.IEnumerator GetEnumerator(System.IO.IsolatedStorage.IsolatedStorageScope scope) { return default(System.Collections.IEnumerator); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public string[] GetFileNames() { return default(string[]); }
+    public string[] GetFileNames(string searchPattern) { return default(string[]); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.DateTimeOffset GetLastAccessTime(string path) { return default(System.DateTimeOffset); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.DateTimeOffset GetLastWriteTime(string path) { return default(System.DateTimeOffset); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetMachineStoreForApplication() { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetMachineStoreForAssembly() { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetMachineStoreForDomain() { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    protected override System.Security.Permissions.IsolatedStoragePermission GetPermission(System.Security.PermissionSet ps) { return default(System.Security.Permissions.IsolatedStoragePermission); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetStore(System.IO.IsolatedStorage.IsolatedStorageScope scope, object applicationIdentity) { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetStore(System.IO.IsolatedStorage.IsolatedStorageScope scope, object domainIdentity, object assemblyIdentity) { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetStore(System.IO.IsolatedStorage.IsolatedStorageScope scope, System.Security.Policy.Evidence domainEvidence, System.Type domainEvidenceType, System.Security.Policy.Evidence assemblyEvidence, System.Type assemblyEvidenceType) { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetStore(System.IO.IsolatedStorage.IsolatedStorageScope scope, System.Type applicationEvidenceType) { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetStore(System.IO.IsolatedStorage.IsolatedStorageScope scope, System.Type domainEvidenceType, System.Type assemblyEvidenceType) { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetUserStoreForApplication() { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetUserStoreForAssembly() { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetUserStoreForDomain() { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public static System.IO.IsolatedStorage.IsolatedStorageFile GetUserStoreForSite() { return default(System.IO.IsolatedStorage.IsolatedStorageFile); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override bool IncreaseQuotaTo(long newQuotaSize) { return default(bool); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void MoveDirectory(string sourceDirectoryName, string destinationDirectoryName) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void MoveFile(string sourceFileName, string destinationFileName) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.IO.IsolatedStorage.IsolatedStorageFileStream OpenFile(string path, System.IO.FileMode mode) { return default(System.IO.IsolatedStorage.IsolatedStorageFileStream); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.IO.IsolatedStorage.IsolatedStorageFileStream OpenFile(string path, System.IO.FileMode mode, System.IO.FileAccess access) { return default(System.IO.IsolatedStorage.IsolatedStorageFileStream); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.IO.IsolatedStorage.IsolatedStorageFileStream OpenFile(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share) { return default(System.IO.IsolatedStorage.IsolatedStorageFileStream); }
+    public override void Remove() { }
+    public static void Remove(System.IO.IsolatedStorage.IsolatedStorageScope scope) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class IsolatedStorageFileStream : System.IO.FileStream {
+    public IsolatedStorageFileStream(string path, System.IO.FileMode mode) : base (default(System.IntPtr), default(System.IO.FileAccess)) { }
+    public IsolatedStorageFileStream(string path, System.IO.FileMode mode, System.IO.FileAccess access) : base (default(System.IntPtr), default(System.IO.FileAccess)) { }
+    public IsolatedStorageFileStream(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share) : base (default(System.IntPtr), default(System.IO.FileAccess)) { }
+    public IsolatedStorageFileStream(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize) : base (default(System.IntPtr), default(System.IO.FileAccess)) { }
+    public IsolatedStorageFileStream(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, int bufferSize, System.IO.IsolatedStorage.IsolatedStorageFile isf) : base (default(System.IntPtr), default(System.IO.FileAccess)) { }
+    public IsolatedStorageFileStream(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, System.IO.IsolatedStorage.IsolatedStorageFile isf) : base (default(System.IntPtr), default(System.IO.FileAccess)) { }
+    public IsolatedStorageFileStream(string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.IsolatedStorage.IsolatedStorageFile isf) : base (default(System.IntPtr), default(System.IO.FileAccess)) { }
+    public IsolatedStorageFileStream(string path, System.IO.FileMode mode, System.IO.IsolatedStorage.IsolatedStorageFile isf) : base (default(System.IntPtr), default(System.IO.FileAccess)) { }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    [System.ObsoleteAttribute("Use SafeFileHandle - once available")]
+    public override System.IntPtr Handle { get { return default(System.IntPtr); } }
+    public override bool IsAsync { get { return default(bool); } }
+    public override long Length { get { return default(long); } }
+    public override long Position { get { return default(long); } set { } }
+    public override Microsoft.Win32.SafeHandles.SafeFileHandle SafeFileHandle { get { return default(Microsoft.Win32.SafeHandles.SafeFileHandle); } }
+    public override System.IAsyncResult BeginRead(byte[] buffer, int offset, int numBytes, System.AsyncCallback userCallback, object stateObject) { return default(System.IAsyncResult); }
+    public override System.IAsyncResult BeginWrite(byte[] buffer, int offset, int numBytes, System.AsyncCallback userCallback, object stateObject) { return default(System.IAsyncResult); }
+    protected override void Dispose(bool disposing) { }
+    public override int EndRead(System.IAsyncResult asyncResult) { return default(int); }
+    public override void EndWrite(System.IAsyncResult asyncResult) { }
+    public override void Flush() { }
+    public override void Flush(bool flushToDisk) { }
+    public override int Read(byte[] buffer, int offset, int count) { return default(int); }
+    public override int ReadByte() { return default(int); }
+    public override long Seek(long offset, System.IO.SeekOrigin origin) { return default(long); }
+    public override void SetLength(long value) { }
+    public override void Write(byte[] buffer, int offset, int count) { }
+    public override void WriteByte(byte value) { }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum IsolatedStorageScope {
+    Application = 32,
+    Assembly = 4,
+    Domain = 2,
+    Machine = 16,
+    None = 0,
+    Roaming = 8,
+    User = 1,
+  }
+
+  public enum IsolatedStorageSecurityOptions {
+    IncreaseQuotaForApplication = 4,
+  }
+
+  public partial class IsolatedStorageSecurityState : System.Security.SecurityState {
+    internal IsolatedStorageSecurityState() { }
+    public System.IO.IsolatedStorage.IsolatedStorageSecurityOptions Options { get { return default(System.IO.IsolatedStorage.IsolatedStorageSecurityOptions); } }
+    public long Quota { get { return default(long); } set { } }
+    public long UsedSize { get { return default(long); } }
+    public override void EnsureState() { }
+  }
+
+} // end of System.IO.IsolatedStorage
+namespace System.Security.Permissions {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum IsolatedStorageContainment {
+    AdministerIsolatedStorageByUser = 112,
+    ApplicationIsolationByMachine = 69,
+    ApplicationIsolationByRoamingUser = 101,
+    ApplicationIsolationByUser = 21,
+    AssemblyIsolationByMachine = 64,
+    AssemblyIsolationByRoamingUser = 96,
+    AssemblyIsolationByUser = 32,
+    DomainIsolationByMachine = 48,
+    DomainIsolationByRoamingUser = 80,
+    DomainIsolationByUser = 16,
+    None = 0,
+    UnrestrictedIsolatedStorage = 240,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class IsolatedStorageFilePermission : System.Security.Permissions.IsolatedStoragePermission {
+    public IsolatedStorageFilePermission(System.Security.Permissions.PermissionState state) : base (default(System.Security.Permissions.PermissionState)) { }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class IsolatedStorageFilePermissionAttribute : System.Security.Permissions.IsolatedStoragePermissionAttribute {
+    public IsolatedStorageFilePermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class IsolatedStoragePermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    protected IsolatedStoragePermission(System.Security.Permissions.PermissionState state) { }
+    public System.Security.Permissions.IsolatedStorageContainment UsageAllowed { get { return default(System.Security.Permissions.IsolatedStorageContainment); } set { } }
+    public long UserQuota { get { return default(long); } set { } }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class IsolatedStoragePermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    protected IsolatedStoragePermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public System.Security.Permissions.IsolatedStorageContainment UsageAllowed { get { return default(System.Security.Permissions.IsolatedStorageContainment); } set { } }
+    public long UserQuota { get { return default(long); } set { } }
+  }
+
+} // end of System.Security.Permissions

fxdac/fxdac/Data/Contracts/System.Runtime.Serialization.Primitives.cs

@@ -0,0 +1,11 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Runtime.Serialization {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class SerializationException : System.SystemException {
+    public SerializationException() { }
+    protected SerializationException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public SerializationException(string message) { }
+    public SerializationException(string message, System.Exception innerException) { }
+  }
+
+} // end of System.Runtime.Serialization

fxdac/fxdac/Data/Contracts/System.Runtime.Versioning.cs

@@ -0,0 +1,55 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Runtime.Versioning {
+  public static partial class CompatibilitySwitch {
+    public static string GetValue(string compatibilitySwitchName) { return default(string); }
+    public static bool IsEnabled(string compatibilitySwitchName) { return default(bool); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(5887), AllowMultiple=false, Inherited=false)]
+  public sealed partial class ComponentGuaranteesAttribute : System.Attribute {
+    public ComponentGuaranteesAttribute(System.Runtime.Versioning.ComponentGuaranteesOptions guarantees) { }
+    public System.Runtime.Versioning.ComponentGuaranteesOptions Guarantees { get { return default(System.Runtime.Versioning.ComponentGuaranteesOptions); } }
+  }
+
+  [System.FlagsAttribute]
+  public enum ComponentGuaranteesOptions {
+    Exchange = 1,
+    None = 0,
+    SideBySide = 4,
+    Stable = 2,
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(224), Inherited=false)]
+  [System.Diagnostics.ConditionalAttribute("RESOURCE_ANNOTATION_WORK")]
+  public sealed partial class ResourceConsumptionAttribute : System.Attribute {
+    public ResourceConsumptionAttribute(System.Runtime.Versioning.ResourceScope resourceScope) { }
+    public ResourceConsumptionAttribute(System.Runtime.Versioning.ResourceScope resourceScope, System.Runtime.Versioning.ResourceScope consumptionScope) { }
+    public System.Runtime.Versioning.ResourceScope ConsumptionScope { get { return default(System.Runtime.Versioning.ResourceScope); } }
+    public System.Runtime.Versioning.ResourceScope ResourceScope { get { return default(System.Runtime.Versioning.ResourceScope); } }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(480), Inherited=false)]
+  [System.Diagnostics.ConditionalAttribute("RESOURCE_ANNOTATION_WORK")]
+  public sealed partial class ResourceExposureAttribute : System.Attribute {
+    public ResourceExposureAttribute(System.Runtime.Versioning.ResourceScope exposureLevel) { }
+    public System.Runtime.Versioning.ResourceScope ResourceExposureLevel { get { return default(System.Runtime.Versioning.ResourceScope); } }
+  }
+
+  [System.FlagsAttribute]
+  public enum ResourceScope {
+    AppDomain = 4,
+    Assembly = 32,
+    Library = 8,
+    Machine = 1,
+    None = 0,
+    Private = 16,
+    Process = 2,
+  }
+
+  public static partial class VersioningHelper {
+    public static string MakeVersionSafeName(string name, System.Runtime.Versioning.ResourceScope from, System.Runtime.Versioning.ResourceScope to) { return default(string); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static string MakeVersionSafeName(string name, System.Runtime.Versioning.ResourceScope from, System.Runtime.Versioning.ResourceScope to, System.Type type) { return default(string); }
+  }
+
+} // end of System.Runtime.Versioning

fxdac/fxdac/Data/Contracts/System.Security.AccessControl.cs

@@ -0,0 +1,822 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.AccessControl {
+  [System.FlagsAttribute]
+  public enum AccessControlActions {
+    Change = 2,
+    None = 0,
+    View = 1,
+  }
+
+  public enum AccessControlModification {
+    Add = 0,
+    Remove = 3,
+    RemoveAll = 4,
+    RemoveSpecific = 5,
+    Reset = 2,
+    Set = 1,
+  }
+
+  [System.FlagsAttribute]
+  public enum AccessControlSections {
+    Access = 2,
+    All = 15,
+    Audit = 1,
+    Group = 8,
+    None = 0,
+    Owner = 4,
+  }
+
+  public enum AccessControlType {
+    Allow = 0,
+    Deny = 1,
+  }
+
+  public abstract partial class AccessRule : System.Security.AccessControl.AuthorizationRule {
+    protected AccessRule(System.Security.Principal.IdentityReference identity, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags)) { }
+    public System.Security.AccessControl.AccessControlType AccessControlType { get { return default(System.Security.AccessControl.AccessControlType); } }
+  }
+
+  public partial class AccessRule<T> : System.Security.AccessControl.AccessRule where T : struct {
+    public AccessRule(System.Security.Principal.IdentityReference identity, T rights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public AccessRule(System.Security.Principal.IdentityReference identity, T rights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public AccessRule(string identity, T rights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public AccessRule(string identity, T rights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public T Rights { get { return default(T); } }
+  }
+
+  public sealed partial class AceEnumerator : System.Collections.IEnumerator {
+    internal AceEnumerator() { }
+    public System.Security.AccessControl.GenericAce Current { get { return default(System.Security.AccessControl.GenericAce); } }
+    object System.Collections.IEnumerator.Current { get { return default(object); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+  [System.FlagsAttribute]
+  public enum AceFlags : byte {
+    AuditFlags = (byte)192,
+    ContainerInherit = (byte)2,
+    FailedAccess = (byte)128,
+    InheritanceFlags = (byte)15,
+    Inherited = (byte)16,
+    InheritOnly = (byte)8,
+    None = (byte)0,
+    NoPropagateInherit = (byte)4,
+    ObjectInherit = (byte)1,
+    SuccessfulAccess = (byte)64,
+  }
+
+  public enum AceQualifier {
+    AccessAllowed = 0,
+    AccessDenied = 1,
+    SystemAlarm = 3,
+    SystemAudit = 2,
+  }
+
+  public enum AceType {
+    AccessAllowed = 0,
+    AccessAllowedCallback = 9,
+    AccessAllowedCallbackObject = 11,
+    AccessAllowedCompound = 4,
+    AccessAllowedObject = 5,
+    AccessDenied = 1,
+    AccessDeniedCallback = 10,
+    AccessDeniedCallbackObject = 12,
+    AccessDeniedObject = 6,
+    MaxDefinedAceType = 16,
+    SystemAlarm = 3,
+    SystemAlarmCallback = 14,
+    SystemAlarmCallbackObject = 16,
+    SystemAlarmObject = 8,
+    SystemAudit = 2,
+    SystemAuditCallback = 13,
+    SystemAuditCallbackObject = 15,
+    SystemAuditObject = 7,
+  }
+
+  [System.FlagsAttribute]
+  public enum AuditFlags {
+    Failure = 2,
+    None = 0,
+    Success = 1,
+  }
+
+  public abstract partial class AuditRule : System.Security.AccessControl.AuthorizationRule {
+    protected AuditRule(System.Security.Principal.IdentityReference identity, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags auditFlags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags)) { }
+    public System.Security.AccessControl.AuditFlags AuditFlags { get { return default(System.Security.AccessControl.AuditFlags); } }
+  }
+
+  public partial class AuditRule<T> : System.Security.AccessControl.AuditRule where T : struct {
+    public AuditRule(System.Security.Principal.IdentityReference identity, T rights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public AuditRule(System.Security.Principal.IdentityReference identity, T rights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public AuditRule(string identity, T rights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public AuditRule(string identity, T rights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public T Rights { get { return default(T); } }
+  }
+
+  public abstract partial class AuthorizationRule {
+    protected internal AuthorizationRule(System.Security.Principal.IdentityReference identity, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { }
+    protected internal int AccessMask { get { return default(int); } }
+    public System.Security.Principal.IdentityReference IdentityReference { get { return default(System.Security.Principal.IdentityReference); } }
+    public System.Security.AccessControl.InheritanceFlags InheritanceFlags { get { return default(System.Security.AccessControl.InheritanceFlags); } }
+    public bool IsInherited { get { return default(bool); } }
+    public System.Security.AccessControl.PropagationFlags PropagationFlags { get { return default(System.Security.AccessControl.PropagationFlags); } }
+  }
+
+  public sealed partial class AuthorizationRuleCollection : System.Collections.ReadOnlyCollectionBase {
+    internal AuthorizationRuleCollection() { }
+    public System.Security.AccessControl.AuthorizationRule this[int index] { get { return default(System.Security.AccessControl.AuthorizationRule); } }
+    public void CopyTo(System.Security.AccessControl.AuthorizationRule[] rules, int index) { }
+  }
+
+  public sealed partial class CommonAce : System.Security.AccessControl.QualifiedAce {
+    public CommonAce(System.Security.AccessControl.AceFlags flags, System.Security.AccessControl.AceQualifier qualifier, int accessMask, System.Security.Principal.SecurityIdentifier sid, bool isCallback, byte[] opaque) { }
+    public override int BinaryLength { get { return default(int); } }
+    public override void GetBinaryForm(byte[] binaryForm, int offset) { }
+    public static int MaxOpaqueLength(bool isCallback) { return default(int); }
+  }
+
+  public abstract partial class CommonAcl : System.Security.AccessControl.GenericAcl {
+    internal CommonAcl() { }
+    public sealed override int BinaryLength { get { return default(int); } }
+    public sealed override int Count { get { return default(int); } }
+    public bool IsCanonical { get { return default(bool); } }
+    public bool IsContainer { get { return default(bool); } }
+    public bool IsDS { get { return default(bool); } }
+    public sealed override System.Security.AccessControl.GenericAce this[int index] { get { return default(System.Security.AccessControl.GenericAce); } set { } }
+    public sealed override byte Revision { get { return default(byte); } }
+    public sealed override void GetBinaryForm(byte[] binaryForm, int offset) { }
+    public void Purge(System.Security.Principal.SecurityIdentifier sid) { }
+    public void RemoveInheritedAces() { }
+  }
+
+  public abstract partial class CommonObjectSecurity : System.Security.AccessControl.ObjectSecurity {
+    protected CommonObjectSecurity(bool isContainer) : base (default(bool), default(bool)) { }
+    protected void AddAccessRule(System.Security.AccessControl.AccessRule rule) { }
+    protected void AddAuditRule(System.Security.AccessControl.AuditRule rule) { }
+    public System.Security.AccessControl.AuthorizationRuleCollection GetAccessRules(bool includeExplicit, bool includeInherited, System.Type targetType) { return default(System.Security.AccessControl.AuthorizationRuleCollection); }
+    public System.Security.AccessControl.AuthorizationRuleCollection GetAuditRules(bool includeExplicit, bool includeInherited, System.Type targetType) { return default(System.Security.AccessControl.AuthorizationRuleCollection); }
+    protected override bool ModifyAccess(System.Security.AccessControl.AccessControlModification modification, System.Security.AccessControl.AccessRule rule, out bool modified) { modified = default(bool); return default(bool); }
+    protected override bool ModifyAudit(System.Security.AccessControl.AccessControlModification modification, System.Security.AccessControl.AuditRule rule, out bool modified) { modified = default(bool); return default(bool); }
+    protected bool RemoveAccessRule(System.Security.AccessControl.AccessRule rule) { return default(bool); }
+    protected void RemoveAccessRuleAll(System.Security.AccessControl.AccessRule rule) { }
+    protected void RemoveAccessRuleSpecific(System.Security.AccessControl.AccessRule rule) { }
+    protected bool RemoveAuditRule(System.Security.AccessControl.AuditRule rule) { return default(bool); }
+    protected void RemoveAuditRuleAll(System.Security.AccessControl.AuditRule rule) { }
+    protected void RemoveAuditRuleSpecific(System.Security.AccessControl.AuditRule rule) { }
+    protected void ResetAccessRule(System.Security.AccessControl.AccessRule rule) { }
+    protected void SetAccessRule(System.Security.AccessControl.AccessRule rule) { }
+    protected void SetAuditRule(System.Security.AccessControl.AuditRule rule) { }
+  }
+
+  public sealed partial class CommonSecurityDescriptor : System.Security.AccessControl.GenericSecurityDescriptor {
+    public CommonSecurityDescriptor(bool isContainer, bool isDS, byte[] binaryForm, int offset) { }
+    public CommonSecurityDescriptor(bool isContainer, bool isDS, System.Security.AccessControl.ControlFlags flags, System.Security.Principal.SecurityIdentifier owner, System.Security.Principal.SecurityIdentifier group, System.Security.AccessControl.SystemAcl systemAcl, System.Security.AccessControl.DiscretionaryAcl discretionaryAcl) { }
+    public CommonSecurityDescriptor(bool isContainer, bool isDS, System.Security.AccessControl.RawSecurityDescriptor rawSecurityDescriptor) { }
+    public CommonSecurityDescriptor(bool isContainer, bool isDS, string sddlForm) { }
+    public override System.Security.AccessControl.ControlFlags ControlFlags { get { return default(System.Security.AccessControl.ControlFlags); } }
+    public System.Security.AccessControl.DiscretionaryAcl DiscretionaryAcl { get { return default(System.Security.AccessControl.DiscretionaryAcl); } set { } }
+    public override System.Security.Principal.SecurityIdentifier Group { get { return default(System.Security.Principal.SecurityIdentifier); } set { } }
+    public bool IsContainer { get { return default(bool); } }
+    public bool IsDiscretionaryAclCanonical { get { return default(bool); } }
+    public bool IsDS { get { return default(bool); } }
+    public bool IsSystemAclCanonical { get { return default(bool); } }
+    public override System.Security.Principal.SecurityIdentifier Owner { get { return default(System.Security.Principal.SecurityIdentifier); } set { } }
+    public System.Security.AccessControl.SystemAcl SystemAcl { get { return default(System.Security.AccessControl.SystemAcl); } set { } }
+    public void PurgeAccessControl(System.Security.Principal.SecurityIdentifier sid) { }
+    public void PurgeAudit(System.Security.Principal.SecurityIdentifier sid) { }
+    public void SetDiscretionaryAclProtection(bool isProtected, bool preserveInheritance) { }
+    public void SetSystemAclProtection(bool isProtected, bool preserveInheritance) { }
+  }
+
+  public sealed partial class CompoundAce : System.Security.AccessControl.KnownAce {
+    public CompoundAce(System.Security.AccessControl.AceFlags flags, int accessMask, System.Security.AccessControl.CompoundAceType compoundAceType, System.Security.Principal.SecurityIdentifier sid) { }
+    public override int BinaryLength { get { return default(int); } }
+    public System.Security.AccessControl.CompoundAceType CompoundAceType { get { return default(System.Security.AccessControl.CompoundAceType); } set { } }
+    public override void GetBinaryForm(byte[] binaryForm, int offset) { }
+  }
+
+  public enum CompoundAceType {
+    Impersonation = 1,
+  }
+
+  [System.FlagsAttribute]
+  public enum ControlFlags {
+    DiscretionaryAclAutoInherited = 1024,
+    DiscretionaryAclAutoInheritRequired = 256,
+    DiscretionaryAclDefaulted = 8,
+    DiscretionaryAclPresent = 4,
+    DiscretionaryAclProtected = 4096,
+    DiscretionaryAclUntrusted = 64,
+    GroupDefaulted = 2,
+    None = 0,
+    OwnerDefaulted = 1,
+    RMControlValid = 16384,
+    SelfRelative = 32768,
+    ServerSecurity = 128,
+    SystemAclAutoInherited = 2048,
+    SystemAclAutoInheritRequired = 512,
+    SystemAclDefaulted = 32,
+    SystemAclPresent = 16,
+    SystemAclProtected = 8192,
+  }
+
+  public sealed partial class CryptoKeyAccessRule : System.Security.AccessControl.AccessRule {
+    public CryptoKeyAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.CryptoKeyRights cryptoKeyRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public CryptoKeyAccessRule(string identity, System.Security.AccessControl.CryptoKeyRights cryptoKeyRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public System.Security.AccessControl.CryptoKeyRights CryptoKeyRights { get { return default(System.Security.AccessControl.CryptoKeyRights); } }
+  }
+
+  public sealed partial class CryptoKeyAuditRule : System.Security.AccessControl.AuditRule {
+    public CryptoKeyAuditRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.CryptoKeyRights cryptoKeyRights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public CryptoKeyAuditRule(string identity, System.Security.AccessControl.CryptoKeyRights cryptoKeyRights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public System.Security.AccessControl.CryptoKeyRights CryptoKeyRights { get { return default(System.Security.AccessControl.CryptoKeyRights); } }
+  }
+
+  [System.FlagsAttribute]
+  public enum CryptoKeyRights {
+    ChangePermissions = 262144,
+    Delete = 65536,
+    FullControl = 2032027,
+    GenericAll = 268435456,
+    GenericExecute = 536870912,
+    GenericRead = -2147483648,
+    GenericWrite = 1073741824,
+    ReadAttributes = 128,
+    ReadData = 1,
+    ReadExtendedAttributes = 8,
+    ReadPermissions = 131072,
+    Synchronize = 1048576,
+    TakeOwnership = 524288,
+    WriteAttributes = 256,
+    WriteData = 2,
+    WriteExtendedAttributes = 16,
+  }
+
+  public sealed partial class CryptoKeySecurity : System.Security.AccessControl.NativeObjectSecurity {
+    public CryptoKeySecurity() : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public CryptoKeySecurity(System.Security.AccessControl.CommonSecurityDescriptor securityDescriptor) : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public override System.Type AccessRightType { get { return default(System.Type); } }
+    public override System.Type AccessRuleType { get { return default(System.Type); } }
+    public override System.Type AuditRuleType { get { return default(System.Type); } }
+    public sealed override System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) { return default(System.Security.AccessControl.AccessRule); }
+    public void AddAccessRule(System.Security.AccessControl.CryptoKeyAccessRule rule) { }
+    public void AddAuditRule(System.Security.AccessControl.CryptoKeyAuditRule rule) { }
+    public sealed override System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) { return default(System.Security.AccessControl.AuditRule); }
+    public bool RemoveAccessRule(System.Security.AccessControl.CryptoKeyAccessRule rule) { return default(bool); }
+    public void RemoveAccessRuleAll(System.Security.AccessControl.CryptoKeyAccessRule rule) { }
+    public void RemoveAccessRuleSpecific(System.Security.AccessControl.CryptoKeyAccessRule rule) { }
+    public bool RemoveAuditRule(System.Security.AccessControl.CryptoKeyAuditRule rule) { return default(bool); }
+    public void RemoveAuditRuleAll(System.Security.AccessControl.CryptoKeyAuditRule rule) { }
+    public void RemoveAuditRuleSpecific(System.Security.AccessControl.CryptoKeyAuditRule rule) { }
+    public void ResetAccessRule(System.Security.AccessControl.CryptoKeyAccessRule rule) { }
+    public void SetAccessRule(System.Security.AccessControl.CryptoKeyAccessRule rule) { }
+    public void SetAuditRule(System.Security.AccessControl.CryptoKeyAuditRule rule) { }
+  }
+
+  public sealed partial class CustomAce : System.Security.AccessControl.GenericAce {
+    public static readonly int MaxOpaqueLength;
+    public CustomAce(System.Security.AccessControl.AceType type, System.Security.AccessControl.AceFlags flags, byte[] opaque) { }
+    public override int BinaryLength { get { return default(int); } }
+    public int OpaqueLength { get { return default(int); } }
+    public override void GetBinaryForm(byte[] binaryForm, int offset) { }
+    public byte[] GetOpaque() { return default(byte[]); }
+    public void SetOpaque(byte[] opaque) { }
+  }
+
+  public sealed partial class DiscretionaryAcl : System.Security.AccessControl.CommonAcl {
+    public DiscretionaryAcl(bool isContainer, bool isDS, byte revision, int capacity) { }
+    public DiscretionaryAcl(bool isContainer, bool isDS, int capacity) { }
+    public DiscretionaryAcl(bool isContainer, bool isDS, System.Security.AccessControl.RawAcl rawAcl) { }
+    public void AddAccess(System.Security.AccessControl.AccessControlType accessType, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { }
+    public void AddAccess(System.Security.AccessControl.AccessControlType accessType, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.ObjectAceFlags objectFlags, System.Guid objectType, System.Guid inheritedObjectType) { }
+    public bool RemoveAccess(System.Security.AccessControl.AccessControlType accessType, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { return default(bool); }
+    public bool RemoveAccess(System.Security.AccessControl.AccessControlType accessType, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.ObjectAceFlags objectFlags, System.Guid objectType, System.Guid inheritedObjectType) { return default(bool); }
+    public void RemoveAccessSpecific(System.Security.AccessControl.AccessControlType accessType, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { }
+    public void RemoveAccessSpecific(System.Security.AccessControl.AccessControlType accessType, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.ObjectAceFlags objectFlags, System.Guid objectType, System.Guid inheritedObjectType) { }
+    public void SetAccess(System.Security.AccessControl.AccessControlType accessType, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { }
+    public void SetAccess(System.Security.AccessControl.AccessControlType accessType, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.ObjectAceFlags objectFlags, System.Guid objectType, System.Guid inheritedObjectType) { }
+  }
+
+  public sealed partial class EventWaitHandleAccessRule : System.Security.AccessControl.AccessRule {
+    public EventWaitHandleAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.EventWaitHandleRights eventRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public EventWaitHandleAccessRule(string identity, System.Security.AccessControl.EventWaitHandleRights eventRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public System.Security.AccessControl.EventWaitHandleRights EventWaitHandleRights { get { return default(System.Security.AccessControl.EventWaitHandleRights); } }
+  }
+
+  public sealed partial class EventWaitHandleAuditRule : System.Security.AccessControl.AuditRule {
+    public EventWaitHandleAuditRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.EventWaitHandleRights eventRights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public System.Security.AccessControl.EventWaitHandleRights EventWaitHandleRights { get { return default(System.Security.AccessControl.EventWaitHandleRights); } }
+  }
+
+  [System.FlagsAttribute]
+  public enum EventWaitHandleRights {
+    ChangePermissions = 262144,
+    Delete = 65536,
+    FullControl = 2031619,
+    Modify = 2,
+    ReadPermissions = 131072,
+    Synchronize = 1048576,
+    TakeOwnership = 524288,
+  }
+
+  public abstract partial class GenericAce {
+    internal GenericAce() { }
+    public System.Security.AccessControl.AceFlags AceFlags { get { return default(System.Security.AccessControl.AceFlags); } set { } }
+    public System.Security.AccessControl.AceType AceType { get { return default(System.Security.AccessControl.AceType); } }
+    public System.Security.AccessControl.AuditFlags AuditFlags { get { return default(System.Security.AccessControl.AuditFlags); } }
+    public abstract int BinaryLength { get; }
+    public System.Security.AccessControl.InheritanceFlags InheritanceFlags { get { return default(System.Security.AccessControl.InheritanceFlags); } }
+    public bool IsInherited { get { return default(bool); } }
+    public System.Security.AccessControl.PropagationFlags PropagationFlags { get { return default(System.Security.AccessControl.PropagationFlags); } }
+    public System.Security.AccessControl.GenericAce Copy() { return default(System.Security.AccessControl.GenericAce); }
+    public static System.Security.AccessControl.GenericAce CreateFromBinaryForm(byte[] binaryForm, int offset) { return default(System.Security.AccessControl.GenericAce); }
+    public sealed override bool Equals(object o) { return default(bool); }
+    public abstract void GetBinaryForm(byte[] binaryForm, int offset);
+    public sealed override int GetHashCode() { return default(int); }
+    public static bool operator ==(System.Security.AccessControl.GenericAce left, System.Security.AccessControl.GenericAce right) { return default(bool); }
+    public static bool operator !=(System.Security.AccessControl.GenericAce left, System.Security.AccessControl.GenericAce right) { return default(bool); }
+  }
+
+  public abstract partial class GenericAcl : System.Collections.ICollection, System.Collections.IEnumerable {
+    public static readonly byte AclRevision;
+    public static readonly byte AclRevisionDS;
+    public static readonly int MaxBinaryLength;
+    protected GenericAcl() { }
+    public abstract int BinaryLength { get; }
+    public abstract int Count { get; }
+    public bool IsSynchronized { get { return default(bool); } }
+    public abstract System.Security.AccessControl.GenericAce this[int index] { get; set; }
+    public abstract byte Revision { get; }
+    public virtual object SyncRoot { get { return default(object); } }
+    public void CopyTo(System.Security.AccessControl.GenericAce[] array, int index) { }
+    public abstract void GetBinaryForm(byte[] binaryForm, int offset);
+    public System.Security.AccessControl.AceEnumerator GetEnumerator() { return default(System.Security.AccessControl.AceEnumerator); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public abstract partial class GenericSecurityDescriptor {
+    protected GenericSecurityDescriptor() { }
+    public int BinaryLength { get { return default(int); } }
+    public abstract System.Security.AccessControl.ControlFlags ControlFlags { get; }
+    public abstract System.Security.Principal.SecurityIdentifier Group { get; set; }
+    public abstract System.Security.Principal.SecurityIdentifier Owner { get; set; }
+    public static byte Revision { get { return default(byte); } }
+    public void GetBinaryForm(byte[] binaryForm, int offset) { }
+    public string GetSddlForm(System.Security.AccessControl.AccessControlSections includeSections) { return default(string); }
+    public static bool IsSddlConversionSupported() { return default(bool); }
+  }
+
+  [System.FlagsAttribute]
+  public enum InheritanceFlags {
+    ContainerInherit = 1,
+    None = 0,
+    ObjectInherit = 2,
+  }
+
+  public abstract partial class KnownAce : System.Security.AccessControl.GenericAce {
+    internal KnownAce() { }
+    public int AccessMask { get { return default(int); } set { } }
+    public System.Security.Principal.SecurityIdentifier SecurityIdentifier { get { return default(System.Security.Principal.SecurityIdentifier); } set { } }
+  }
+
+  public sealed partial class MutexAccessRule : System.Security.AccessControl.AccessRule {
+    public MutexAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.MutexRights eventRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public MutexAccessRule(string identity, System.Security.AccessControl.MutexRights eventRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public System.Security.AccessControl.MutexRights MutexRights { get { return default(System.Security.AccessControl.MutexRights); } }
+  }
+
+  public sealed partial class MutexAuditRule : System.Security.AccessControl.AuditRule {
+    public MutexAuditRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.MutexRights eventRights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public System.Security.AccessControl.MutexRights MutexRights { get { return default(System.Security.AccessControl.MutexRights); } }
+  }
+
+  [System.FlagsAttribute]
+  public enum MutexRights {
+    ChangePermissions = 262144,
+    Delete = 65536,
+    FullControl = 2031617,
+    Modify = 1,
+    ReadPermissions = 131072,
+    Synchronize = 1048576,
+    TakeOwnership = 524288,
+  }
+
+  public sealed partial class MutexSecurity : System.Security.AccessControl.NativeObjectSecurity {
+    public MutexSecurity() : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public MutexSecurity(string name, System.Security.AccessControl.AccessControlSections includeSections) : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public override System.Type AccessRightType { get { return default(System.Type); } }
+    public override System.Type AccessRuleType { get { return default(System.Type); } }
+    public override System.Type AuditRuleType { get { return default(System.Type); } }
+    public override System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) { return default(System.Security.AccessControl.AccessRule); }
+    public void AddAccessRule(System.Security.AccessControl.MutexAccessRule rule) { }
+    public void AddAuditRule(System.Security.AccessControl.MutexAuditRule rule) { }
+    public override System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) { return default(System.Security.AccessControl.AuditRule); }
+    public bool RemoveAccessRule(System.Security.AccessControl.MutexAccessRule rule) { return default(bool); }
+    public void RemoveAccessRuleAll(System.Security.AccessControl.MutexAccessRule rule) { }
+    public void RemoveAccessRuleSpecific(System.Security.AccessControl.MutexAccessRule rule) { }
+    public bool RemoveAuditRule(System.Security.AccessControl.MutexAuditRule rule) { return default(bool); }
+    public void RemoveAuditRuleAll(System.Security.AccessControl.MutexAuditRule rule) { }
+    public void RemoveAuditRuleSpecific(System.Security.AccessControl.MutexAuditRule rule) { }
+    public void ResetAccessRule(System.Security.AccessControl.MutexAccessRule rule) { }
+    public void SetAccessRule(System.Security.AccessControl.MutexAccessRule rule) { }
+    public void SetAuditRule(System.Security.AccessControl.MutexAuditRule rule) { }
+  }
+
+  public abstract partial class NativeObjectSecurity : System.Security.AccessControl.CommonObjectSecurity {
+    protected NativeObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType) : base (default(bool)) { }
+    protected NativeObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, System.Runtime.InteropServices.SafeHandle handle, System.Security.AccessControl.AccessControlSections includeSections) : base (default(bool)) { }
+    protected NativeObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, System.Runtime.InteropServices.SafeHandle handle, System.Security.AccessControl.AccessControlSections includeSections, System.Security.AccessControl.NativeObjectSecurity.ExceptionFromErrorCode exceptionFromErrorCode, object exceptionContext) : base (default(bool)) { }
+    protected NativeObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, System.Security.AccessControl.NativeObjectSecurity.ExceptionFromErrorCode exceptionFromErrorCode, object exceptionContext) : base (default(bool)) { }
+    protected NativeObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, string name, System.Security.AccessControl.AccessControlSections includeSections) : base (default(bool)) { }
+    protected NativeObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, string name, System.Security.AccessControl.AccessControlSections includeSections, System.Security.AccessControl.NativeObjectSecurity.ExceptionFromErrorCode exceptionFromErrorCode, object exceptionContext) : base (default(bool)) { }
+    protected sealed override void Persist(System.Runtime.InteropServices.SafeHandle handle, System.Security.AccessControl.AccessControlSections includeSections) { }
+    protected void Persist(System.Runtime.InteropServices.SafeHandle handle, System.Security.AccessControl.AccessControlSections includeSections, object exceptionContext) { }
+    protected sealed override void Persist(string name, System.Security.AccessControl.AccessControlSections includeSections) { }
+    protected void Persist(string name, System.Security.AccessControl.AccessControlSections includeSections, object exceptionContext) { }
+    protected internal delegate System.Exception ExceptionFromErrorCode(int errorCode, string name, System.Runtime.InteropServices.SafeHandle handle, object context);
+  }
+
+  public abstract partial class ObjectAccessRule : System.Security.AccessControl.AccessRule {
+    protected ObjectAccessRule(System.Security.Principal.IdentityReference identity, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Guid objectType, System.Guid inheritedObjectType, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public System.Guid InheritedObjectType { get { return default(System.Guid); } }
+    public System.Security.AccessControl.ObjectAceFlags ObjectFlags { get { return default(System.Security.AccessControl.ObjectAceFlags); } }
+    public System.Guid ObjectType { get { return default(System.Guid); } }
+  }
+
+  public sealed partial class ObjectAce : System.Security.AccessControl.QualifiedAce {
+    public ObjectAce(System.Security.AccessControl.AceFlags aceFlags, System.Security.AccessControl.AceQualifier qualifier, int accessMask, System.Security.Principal.SecurityIdentifier sid, System.Security.AccessControl.ObjectAceFlags flags, System.Guid type, System.Guid inheritedType, bool isCallback, byte[] opaque) { }
+    public override int BinaryLength { get { return default(int); } }
+    public System.Guid InheritedObjectAceType { get { return default(System.Guid); } set { } }
+    public System.Security.AccessControl.ObjectAceFlags ObjectAceFlags { get { return default(System.Security.AccessControl.ObjectAceFlags); } set { } }
+    public System.Guid ObjectAceType { get { return default(System.Guid); } set { } }
+    public override void GetBinaryForm(byte[] binaryForm, int offset) { }
+    public static int MaxOpaqueLength(bool isCallback) { return default(int); }
+  }
+
+  [System.FlagsAttribute]
+  public enum ObjectAceFlags {
+    InheritedObjectAceTypePresent = 2,
+    None = 0,
+    ObjectAceTypePresent = 1,
+  }
+
+  public abstract partial class ObjectAuditRule : System.Security.AccessControl.AuditRule {
+    protected ObjectAuditRule(System.Security.Principal.IdentityReference identity, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Guid objectType, System.Guid inheritedObjectType, System.Security.AccessControl.AuditFlags auditFlags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public System.Guid InheritedObjectType { get { return default(System.Guid); } }
+    public System.Security.AccessControl.ObjectAceFlags ObjectFlags { get { return default(System.Security.AccessControl.ObjectAceFlags); } }
+    public System.Guid ObjectType { get { return default(System.Guid); } }
+  }
+
+  public abstract partial class ObjectSecurity {
+    protected ObjectSecurity(bool isContainer, bool isDS) { }
+    public abstract System.Type AccessRightType { get; }
+    protected bool AccessRulesModified { get { return default(bool); } set { } }
+    public abstract System.Type AccessRuleType { get; }
+    public bool AreAccessRulesCanonical { get { return default(bool); } }
+    public bool AreAccessRulesProtected { get { return default(bool); } }
+    public bool AreAuditRulesCanonical { get { return default(bool); } }
+    public bool AreAuditRulesProtected { get { return default(bool); } }
+    protected bool AuditRulesModified { get { return default(bool); } set { } }
+    public abstract System.Type AuditRuleType { get; }
+    protected bool GroupModified { get { return default(bool); } set { } }
+    protected bool IsContainer { get { return default(bool); } }
+    protected bool IsDS { get { return default(bool); } }
+    protected bool OwnerModified { get { return default(bool); } set { } }
+    public abstract System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type);
+    public abstract System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags);
+    public System.Security.Principal.IdentityReference GetGroup(System.Type targetType) { return default(System.Security.Principal.IdentityReference); }
+    public System.Security.Principal.IdentityReference GetOwner(System.Type targetType) { return default(System.Security.Principal.IdentityReference); }
+    public byte[] GetSecurityDescriptorBinaryForm() { return default(byte[]); }
+    public string GetSecurityDescriptorSddlForm(System.Security.AccessControl.AccessControlSections includeSections) { return default(string); }
+    public static bool IsSddlConversionSupported() { return default(bool); }
+    protected abstract bool ModifyAccess(System.Security.AccessControl.AccessControlModification modification, System.Security.AccessControl.AccessRule rule, out bool modified);
+    public virtual bool ModifyAccessRule(System.Security.AccessControl.AccessControlModification modification, System.Security.AccessControl.AccessRule rule, out bool modified) { modified = default(bool); return default(bool); }
+    protected abstract bool ModifyAudit(System.Security.AccessControl.AccessControlModification modification, System.Security.AccessControl.AuditRule rule, out bool modified);
+    public virtual bool ModifyAuditRule(System.Security.AccessControl.AccessControlModification modification, System.Security.AccessControl.AuditRule rule, out bool modified) { modified = default(bool); return default(bool); }
+    [System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptionsAttribute]
+    protected virtual void Persist(bool enableOwnershipPrivilege, string name, System.Security.AccessControl.AccessControlSections includeSections) { }
+    protected virtual void Persist(System.Runtime.InteropServices.SafeHandle handle, System.Security.AccessControl.AccessControlSections includeSections) { }
+    protected virtual void Persist(string name, System.Security.AccessControl.AccessControlSections includeSections) { }
+    public virtual void PurgeAccessRules(System.Security.Principal.IdentityReference identity) { }
+    public virtual void PurgeAuditRules(System.Security.Principal.IdentityReference identity) { }
+    protected void ReadLock() { }
+    protected void ReadUnlock() { }
+    public void SetAccessRuleProtection(bool isProtected, bool preserveInheritance) { }
+    public void SetAuditRuleProtection(bool isProtected, bool preserveInheritance) { }
+    public void SetGroup(System.Security.Principal.IdentityReference identity) { }
+    public void SetOwner(System.Security.Principal.IdentityReference identity) { }
+    public void SetSecurityDescriptorBinaryForm(byte[] binaryForm) { }
+    public void SetSecurityDescriptorBinaryForm(byte[] binaryForm, System.Security.AccessControl.AccessControlSections includeSections) { }
+    public void SetSecurityDescriptorSddlForm(string sddlForm) { }
+    public void SetSecurityDescriptorSddlForm(string sddlForm, System.Security.AccessControl.AccessControlSections includeSections) { }
+    protected void WriteLock() { }
+    protected void WriteUnlock() { }
+  }
+
+  public abstract partial class ObjectSecurity<T> : System.Security.AccessControl.NativeObjectSecurity where T : struct {
+    protected ObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType) : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    protected ObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, System.Runtime.InteropServices.SafeHandle safeHandle, System.Security.AccessControl.AccessControlSections includeSections) : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    protected ObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, System.Runtime.InteropServices.SafeHandle safeHandle, System.Security.AccessControl.AccessControlSections includeSections, System.Security.AccessControl.NativeObjectSecurity.ExceptionFromErrorCode exceptionFromErrorCode, object exceptionContext) : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    protected ObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, string name, System.Security.AccessControl.AccessControlSections includeSections) : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    protected ObjectSecurity(bool isContainer, System.Security.AccessControl.ResourceType resourceType, string name, System.Security.AccessControl.AccessControlSections includeSections, System.Security.AccessControl.NativeObjectSecurity.ExceptionFromErrorCode exceptionFromErrorCode, object exceptionContext) : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public override System.Type AccessRightType { get { return default(System.Type); } }
+    public override System.Type AccessRuleType { get { return default(System.Type); } }
+    public override System.Type AuditRuleType { get { return default(System.Type); } }
+    public override System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) { return default(System.Security.AccessControl.AccessRule); }
+    public virtual void AddAccessRule(System.Security.AccessControl.AccessRule<T> rule) { }
+    public virtual void AddAuditRule(System.Security.AccessControl.AuditRule<T> rule) { }
+    public override System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) { return default(System.Security.AccessControl.AuditRule); }
+    protected void Persist(System.Runtime.InteropServices.SafeHandle handle) { }
+    protected void Persist(string name) { }
+    public virtual bool RemoveAccessRule(System.Security.AccessControl.AccessRule<T> rule) { return default(bool); }
+    public virtual void RemoveAccessRuleAll(System.Security.AccessControl.AccessRule<T> rule) { }
+    public virtual void RemoveAccessRuleSpecific(System.Security.AccessControl.AccessRule<T> rule) { }
+    public virtual bool RemoveAuditRule(System.Security.AccessControl.AuditRule<T> rule) { return default(bool); }
+    public virtual void RemoveAuditRuleAll(System.Security.AccessControl.AuditRule<T> rule) { }
+    public virtual void RemoveAuditRuleSpecific(System.Security.AccessControl.AuditRule<T> rule) { }
+    public virtual void ResetAccessRule(System.Security.AccessControl.AccessRule<T> rule) { }
+    public virtual void SetAccessRule(System.Security.AccessControl.AccessRule<T> rule) { }
+    public virtual void SetAuditRule(System.Security.AccessControl.AuditRule<T> rule) { }
+  }
+
+  public sealed partial class PrivilegeNotHeldException : System.UnauthorizedAccessException, System.Runtime.Serialization.ISerializable {
+    public PrivilegeNotHeldException() { }
+    public PrivilegeNotHeldException(string privilege) { }
+    public PrivilegeNotHeldException(string privilege, System.Exception inner) { }
+    public string PrivilegeName { get { return default(string); } }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+  }
+
+  [System.FlagsAttribute]
+  public enum PropagationFlags {
+    InheritOnly = 2,
+    None = 0,
+    NoPropagateInherit = 1,
+  }
+
+  public abstract partial class QualifiedAce : System.Security.AccessControl.KnownAce {
+    internal QualifiedAce() { }
+    public System.Security.AccessControl.AceQualifier AceQualifier { get { return default(System.Security.AccessControl.AceQualifier); } }
+    public bool IsCallback { get { return default(bool); } }
+    public int OpaqueLength { get { return default(int); } }
+    public byte[] GetOpaque() { return default(byte[]); }
+    public void SetOpaque(byte[] opaque) { }
+  }
+
+  public sealed partial class RawAcl : System.Security.AccessControl.GenericAcl {
+    public RawAcl(byte revision, int capacity) { }
+    public RawAcl(byte[] binaryForm, int offset) { }
+    public override int BinaryLength { get { return default(int); } }
+    public override int Count { get { return default(int); } }
+    public override System.Security.AccessControl.GenericAce this[int index] { get { return default(System.Security.AccessControl.GenericAce); } set { } }
+    public override byte Revision { get { return default(byte); } }
+    public override void GetBinaryForm(byte[] binaryForm, int offset) { }
+    public void InsertAce(int index, System.Security.AccessControl.GenericAce ace) { }
+    public void RemoveAce(int index) { }
+  }
+
+  public sealed partial class RawSecurityDescriptor : System.Security.AccessControl.GenericSecurityDescriptor {
+    public RawSecurityDescriptor(byte[] binaryForm, int offset) { }
+    public RawSecurityDescriptor(System.Security.AccessControl.ControlFlags flags, System.Security.Principal.SecurityIdentifier owner, System.Security.Principal.SecurityIdentifier group, System.Security.AccessControl.RawAcl systemAcl, System.Security.AccessControl.RawAcl discretionaryAcl) { }
+    public RawSecurityDescriptor(string sddlForm) { }
+    public override System.Security.AccessControl.ControlFlags ControlFlags { get { return default(System.Security.AccessControl.ControlFlags); } }
+    public System.Security.AccessControl.RawAcl DiscretionaryAcl { get { return default(System.Security.AccessControl.RawAcl); } set { } }
+    public override System.Security.Principal.SecurityIdentifier Group { get { return default(System.Security.Principal.SecurityIdentifier); } set { } }
+    public override System.Security.Principal.SecurityIdentifier Owner { get { return default(System.Security.Principal.SecurityIdentifier); } set { } }
+    public byte ResourceManagerControl { get { return default(byte); } set { } }
+    public System.Security.AccessControl.RawAcl SystemAcl { get { return default(System.Security.AccessControl.RawAcl); } set { } }
+    public void SetFlags(System.Security.AccessControl.ControlFlags flags) { }
+  }
+
+  public sealed partial class RegistryAccessRule : System.Security.AccessControl.AccessRule {
+    public RegistryAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.RegistryRights registryRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public RegistryAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.RegistryRights registryRights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public RegistryAccessRule(string identity, System.Security.AccessControl.RegistryRights registryRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public RegistryAccessRule(string identity, System.Security.AccessControl.RegistryRights registryRights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public System.Security.AccessControl.RegistryRights RegistryRights { get { return default(System.Security.AccessControl.RegistryRights); } }
+  }
+
+  public sealed partial class RegistryAuditRule : System.Security.AccessControl.AuditRule {
+    public RegistryAuditRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.RegistryRights registryRights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public RegistryAuditRule(string identity, System.Security.AccessControl.RegistryRights registryRights, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public System.Security.AccessControl.RegistryRights RegistryRights { get { return default(System.Security.AccessControl.RegistryRights); } }
+  }
+
+  [System.FlagsAttribute]
+  public enum RegistryRights {
+    ChangePermissions = 262144,
+    CreateLink = 32,
+    CreateSubKey = 4,
+    Delete = 65536,
+    EnumerateSubKeys = 8,
+    ExecuteKey = 131097,
+    FullControl = 983103,
+    Notify = 16,
+    QueryValues = 1,
+    ReadKey = 131097,
+    ReadPermissions = 131072,
+    SetValue = 2,
+    TakeOwnership = 524288,
+    WriteKey = 131078,
+  }
+
+  public sealed partial class RegistrySecurity : System.Security.AccessControl.NativeObjectSecurity {
+    public RegistrySecurity() : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public override System.Type AccessRightType { get { return default(System.Type); } }
+    public override System.Type AccessRuleType { get { return default(System.Type); } }
+    public override System.Type AuditRuleType { get { return default(System.Type); } }
+    public override System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) { return default(System.Security.AccessControl.AccessRule); }
+    public void AddAccessRule(System.Security.AccessControl.RegistryAccessRule rule) { }
+    public void AddAuditRule(System.Security.AccessControl.RegistryAuditRule rule) { }
+    public override System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) { return default(System.Security.AccessControl.AuditRule); }
+    public bool RemoveAccessRule(System.Security.AccessControl.RegistryAccessRule rule) { return default(bool); }
+    public void RemoveAccessRuleAll(System.Security.AccessControl.RegistryAccessRule rule) { }
+    public void RemoveAccessRuleSpecific(System.Security.AccessControl.RegistryAccessRule rule) { }
+    public bool RemoveAuditRule(System.Security.AccessControl.RegistryAuditRule rule) { return default(bool); }
+    public void RemoveAuditRuleAll(System.Security.AccessControl.RegistryAuditRule rule) { }
+    public void RemoveAuditRuleSpecific(System.Security.AccessControl.RegistryAuditRule rule) { }
+    public void ResetAccessRule(System.Security.AccessControl.RegistryAccessRule rule) { }
+    public void SetAccessRule(System.Security.AccessControl.RegistryAccessRule rule) { }
+    public void SetAuditRule(System.Security.AccessControl.RegistryAuditRule rule) { }
+  }
+
+  public enum ResourceType {
+    DSObject = 8,
+    DSObjectAll = 9,
+    FileObject = 1,
+    KernelObject = 6,
+    LMShare = 5,
+    Printer = 3,
+    ProviderDefined = 10,
+    RegistryKey = 4,
+    RegistryWow6432Key = 12,
+    Service = 2,
+    Unknown = 0,
+    WindowObject = 7,
+    WmiGuidObject = 11,
+  }
+
+  [System.FlagsAttribute]
+  public enum SecurityInfos {
+    DiscretionaryAcl = 4,
+    Group = 2,
+    Owner = 1,
+    SystemAcl = 8,
+  }
+
+  public sealed partial class SystemAcl : System.Security.AccessControl.CommonAcl {
+    public SystemAcl(bool isContainer, bool isDS, byte revision, int capacity) { }
+    public SystemAcl(bool isContainer, bool isDS, int capacity) { }
+    public SystemAcl(bool isContainer, bool isDS, System.Security.AccessControl.RawAcl rawAcl) { }
+    public void AddAudit(System.Security.AccessControl.AuditFlags auditFlags, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { }
+    public void AddAudit(System.Security.AccessControl.AuditFlags auditFlags, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.ObjectAceFlags objectFlags, System.Guid objectType, System.Guid inheritedObjectType) { }
+    public bool RemoveAudit(System.Security.AccessControl.AuditFlags auditFlags, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { return default(bool); }
+    public bool RemoveAudit(System.Security.AccessControl.AuditFlags auditFlags, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.ObjectAceFlags objectFlags, System.Guid objectType, System.Guid inheritedObjectType) { return default(bool); }
+    public void RemoveAuditSpecific(System.Security.AccessControl.AuditFlags auditFlags, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { }
+    public void RemoveAuditSpecific(System.Security.AccessControl.AuditFlags auditFlags, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.ObjectAceFlags objectFlags, System.Guid objectType, System.Guid inheritedObjectType) { }
+    public void SetAudit(System.Security.AccessControl.AuditFlags auditFlags, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags) { }
+    public void SetAudit(System.Security.AccessControl.AuditFlags auditFlags, System.Security.Principal.SecurityIdentifier sid, int accessMask, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.ObjectAceFlags objectFlags, System.Guid objectType, System.Guid inheritedObjectType) { }
+  }
+
+} // end of System.Security.AccessControl
+namespace System.Security.Principal {
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public abstract partial class IdentityReference {
+    internal IdentityReference() { }
+    public abstract string Value { get; }
+    public abstract override bool Equals(object o);
+    public abstract override int GetHashCode();
+    public abstract bool IsValidTargetType(System.Type targetType);
+    public static bool operator ==(System.Security.Principal.IdentityReference left, System.Security.Principal.IdentityReference right) { return default(bool); }
+    public static bool operator !=(System.Security.Principal.IdentityReference left, System.Security.Principal.IdentityReference right) { return default(bool); }
+    public abstract override string ToString();
+    public abstract System.Security.Principal.IdentityReference Translate(System.Type targetType);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class IdentityReferenceCollection : System.Collections.Generic.ICollection<System.Security.Principal.IdentityReference>, System.Collections.Generic.IEnumerable<System.Security.Principal.IdentityReference>, System.Collections.IEnumerable {
+    public IdentityReferenceCollection() { }
+    public IdentityReferenceCollection(int capacity) { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public System.Security.Principal.IdentityReference this[int index] { get { return default(System.Security.Principal.IdentityReference); } set { } }
+    public void Add(System.Security.Principal.IdentityReference identity) { }
+    public void Clear() { }
+    public bool Contains(System.Security.Principal.IdentityReference identity) { return default(bool); }
+    public void CopyTo(System.Security.Principal.IdentityReference[] array, int offset) { }
+    public System.Collections.Generic.IEnumerator<System.Security.Principal.IdentityReference> GetEnumerator() { return default(System.Collections.Generic.IEnumerator<System.Security.Principal.IdentityReference>); }
+    public bool Remove(System.Security.Principal.IdentityReference identity) { return default(bool); }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+    public System.Security.Principal.IdentityReferenceCollection Translate(System.Type targetType) { return default(System.Security.Principal.IdentityReferenceCollection); }
+    public System.Security.Principal.IdentityReferenceCollection Translate(System.Type targetType, bool forceSuccess) { return default(System.Security.Principal.IdentityReferenceCollection); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public sealed partial class NTAccount : System.Security.Principal.IdentityReference {
+    public NTAccount(string name) { }
+    public NTAccount(string domainName, string accountName) { }
+    public override string Value { get { return default(string); } }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override bool IsValidTargetType(System.Type targetType) { return default(bool); }
+    public static bool operator ==(System.Security.Principal.NTAccount left, System.Security.Principal.NTAccount right) { return default(bool); }
+    public static bool operator !=(System.Security.Principal.NTAccount left, System.Security.Principal.NTAccount right) { return default(bool); }
+    public override string ToString() { return default(string); }
+    public override System.Security.Principal.IdentityReference Translate(System.Type targetType) { return default(System.Security.Principal.IdentityReference); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public sealed partial class SecurityIdentifier : System.Security.Principal.IdentityReference, System.IComparable<System.Security.Principal.SecurityIdentifier> {
+    public static readonly int MaxBinaryLength;
+    public static readonly int MinBinaryLength;
+    public SecurityIdentifier(byte[] binaryForm, int offset) { }
+    public SecurityIdentifier(System.IntPtr binaryForm) { }
+    public SecurityIdentifier(System.Security.Principal.WellKnownSidType sidType, System.Security.Principal.SecurityIdentifier domainSid) { }
+    public SecurityIdentifier(string sddlForm) { }
+    public System.Security.Principal.SecurityIdentifier AccountDomainSid { get { return default(System.Security.Principal.SecurityIdentifier); } }
+    public int BinaryLength { get { return default(int); } }
+    public override string Value { get { return default(string); } }
+    public int CompareTo(System.Security.Principal.SecurityIdentifier sid) { return default(int); }
+    public override bool Equals(object o) { return default(bool); }
+    public bool Equals(System.Security.Principal.SecurityIdentifier sid) { return default(bool); }
+    public void GetBinaryForm(byte[] binaryForm, int offset) { }
+    public override int GetHashCode() { return default(int); }
+    public bool IsAccountSid() { return default(bool); }
+    public bool IsEqualDomainSid(System.Security.Principal.SecurityIdentifier sid) { return default(bool); }
+    public override bool IsValidTargetType(System.Type targetType) { return default(bool); }
+    public bool IsWellKnown(System.Security.Principal.WellKnownSidType type) { return default(bool); }
+    public static bool operator ==(System.Security.Principal.SecurityIdentifier left, System.Security.Principal.SecurityIdentifier right) { return default(bool); }
+    public static bool operator !=(System.Security.Principal.SecurityIdentifier left, System.Security.Principal.SecurityIdentifier right) { return default(bool); }
+    public override string ToString() { return default(string); }
+    public override System.Security.Principal.IdentityReference Translate(System.Type targetType) { return default(System.Security.Principal.IdentityReference); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public enum WellKnownSidType {
+    AccountAdministratorSid = 38,
+    AccountCertAdminsSid = 46,
+    AccountComputersSid = 44,
+    AccountControllersSid = 45,
+    AccountDomainAdminsSid = 41,
+    AccountDomainGuestsSid = 43,
+    AccountDomainUsersSid = 42,
+    AccountEnterpriseAdminsSid = 48,
+    AccountGuestSid = 39,
+    AccountKrbtgtSid = 40,
+    AccountPolicyAdminsSid = 49,
+    AccountRasAndIasServersSid = 50,
+    AccountSchemaAdminsSid = 47,
+    AnonymousSid = 13,
+    AuthenticatedUserSid = 17,
+    BatchSid = 10,
+    BuiltinAccountOperatorsSid = 30,
+    BuiltinAdministratorsSid = 26,
+    BuiltinAuthorizationAccessSid = 59,
+    BuiltinBackupOperatorsSid = 33,
+    BuiltinDomainSid = 25,
+    BuiltinGuestsSid = 28,
+    BuiltinIncomingForestTrustBuildersSid = 56,
+    BuiltinNetworkConfigurationOperatorsSid = 37,
+    BuiltinPerformanceLoggingUsersSid = 58,
+    BuiltinPerformanceMonitoringUsersSid = 57,
+    BuiltinPowerUsersSid = 29,
+    BuiltinPreWindows2000CompatibleAccessSid = 35,
+    BuiltinPrintOperatorsSid = 32,
+    BuiltinRemoteDesktopUsersSid = 36,
+    BuiltinReplicatorSid = 34,
+    BuiltinSystemOperatorsSid = 31,
+    BuiltinUsersSid = 27,
+    CreatorGroupServerSid = 6,
+    CreatorGroupSid = 4,
+    CreatorOwnerServerSid = 5,
+    CreatorOwnerSid = 3,
+    DialupSid = 8,
+    DigestAuthenticationSid = 52,
+    EnterpriseControllersSid = 15,
+    InteractiveSid = 11,
+    LocalServiceSid = 23,
+    LocalSid = 2,
+    LocalSystemSid = 22,
+    LogonIdsSid = 21,
+    MaxDefined = 60,
+    NetworkServiceSid = 24,
+    NetworkSid = 9,
+    NTAuthoritySid = 7,
+    NtlmAuthenticationSid = 51,
+    NullSid = 0,
+    OtherOrganizationSid = 55,
+    ProxySid = 14,
+    RemoteLogonIdSid = 20,
+    RestrictedCodeSid = 18,
+    SChannelAuthenticationSid = 53,
+    SelfSid = 16,
+    ServiceSid = 12,
+    TerminalServerSid = 19,
+    ThisOrganizationSid = 54,
+    WinBuiltinTerminalServerLicenseServersSid = 60,
+    WorldSid = 1,
+  }
+
+} // end of System.Security.Principal

fxdac/fxdac/Data/Contracts/System.Security.Authentication.ExtendedProtection.cs

@@ -0,0 +1,9 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Authentication.ExtendedProtection {
+  public partial class ExtendedProtectionPolicyTypeConverter : System.ComponentModel.TypeConverter {
+    public ExtendedProtectionPolicyTypeConverter() { }
+    public override bool CanConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Type destinationType) { return default(bool); }
+    public override object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, System.Type destinationType) { return default(object); }
+  }
+
+} // end of System.Security.Authentication.ExtendedProtection

fxdac/fxdac/Data/Contracts/System.Security.Claims.cs

@@ -0,0 +1,208 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Claims {
+  public partial class Claim {
+    public Claim(string type, string value) { }
+    public Claim(string type, string value, string valueType) { }
+    public Claim(string type, string value, string valueType, string issuer) { }
+    public Claim(string type, string value, string valueType, string issuer, string originalIssuer) { }
+    public Claim(string type, string value, string valueType, string issuer, string originalIssuer, System.Security.Claims.ClaimsIdentity subject) { }
+    public string Issuer { get { return default(string); } }
+    public string OriginalIssuer { get { return default(string); } }
+    public System.Collections.Generic.IDictionary<string, string> Properties { get { return default(System.Collections.Generic.IDictionary<string, string>); } }
+    public System.Security.Claims.ClaimsIdentity Subject { get { return default(System.Security.Claims.ClaimsIdentity); } }
+    public string Type { get { return default(string); } }
+    public string Value { get { return default(string); } }
+    public string ValueType { get { return default(string); } }
+    public virtual System.Security.Claims.Claim Clone() { return default(System.Security.Claims.Claim); }
+    public virtual System.Security.Claims.Claim Clone(System.Security.Claims.ClaimsIdentity identity) { return default(System.Security.Claims.Claim); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ClaimsIdentity : System.Security.Principal.IIdentity {
+    public const string DefaultIssuer = "LOCAL AUTHORITY";
+    public const string DefaultNameClaimType = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name";
+    public const string DefaultRoleClaimType = "http://schemas.microsoft.com/ws/2008/06/identity/claims/role";
+    public ClaimsIdentity() { }
+    public ClaimsIdentity(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> claims) { }
+    public ClaimsIdentity(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> claims, string authenticationType) { }
+    public ClaimsIdentity(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> claims, string authenticationType, string nameType, string roleType) { }
+    [System.Security.SecurityCriticalAttribute]
+    protected ClaimsIdentity(System.Runtime.Serialization.SerializationInfo info) { }
+    [System.Security.SecurityCriticalAttribute]
+    protected ClaimsIdentity(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public ClaimsIdentity(System.Security.Principal.IIdentity identity) { }
+    public ClaimsIdentity(System.Security.Principal.IIdentity identity, System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> claims) { }
+    public ClaimsIdentity(System.Security.Principal.IIdentity identity, System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> claims, string authenticationType, string nameType, string roleType) { }
+    public ClaimsIdentity(string authenticationType) { }
+    public ClaimsIdentity(string authenticationType, string nameType, string roleType) { }
+    public System.Security.Claims.ClaimsIdentity Actor { get { return default(System.Security.Claims.ClaimsIdentity); } set { } }
+    public virtual string AuthenticationType { get { return default(string); } }
+    public object BootstrapContext { get { return default(object); } [System.Security.SecurityCriticalAttribute]set { } }
+    public virtual System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> Claims { get { return default(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>); } }
+    public virtual bool IsAuthenticated { get { return default(bool); } }
+    public string Label { get { return default(string); } set { } }
+    public virtual string Name { get { return default(string); } }
+    public string NameClaimType { get { return default(string); } }
+    public string RoleClaimType { get { return default(string); } }
+    [System.Security.SecurityCriticalAttribute]
+    public virtual void AddClaim(System.Security.Claims.Claim claim) { }
+    [System.Security.SecurityCriticalAttribute]
+    public virtual void AddClaims(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> claims) { }
+    public virtual System.Security.Claims.ClaimsIdentity Clone() { return default(System.Security.Claims.ClaimsIdentity); }
+    public virtual System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> FindAll(System.Predicate<System.Security.Claims.Claim> match) { return default(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>); }
+    public virtual System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> FindAll(string type) { return default(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>); }
+    public virtual System.Security.Claims.Claim FindFirst(System.Predicate<System.Security.Claims.Claim> match) { return default(System.Security.Claims.Claim); }
+    public virtual System.Security.Claims.Claim FindFirst(string type) { return default(System.Security.Claims.Claim); }
+    [System.Security.SecurityCriticalAttribute]
+    protected virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public virtual bool HasClaim(System.Predicate<System.Security.Claims.Claim> match) { return default(bool); }
+    public virtual bool HasClaim(string type, string value) { return default(bool); }
+    [System.Security.SecurityCriticalAttribute]
+    public virtual void RemoveClaim(System.Security.Claims.Claim claim) { }
+    [System.Security.SecurityCriticalAttribute]
+    public virtual bool TryRemoveClaim(System.Security.Claims.Claim claim) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ClaimsPrincipal : System.Security.Principal.IPrincipal {
+    public ClaimsPrincipal() { }
+    public ClaimsPrincipal(System.Collections.Generic.IEnumerable<System.Security.Claims.ClaimsIdentity> identities) { }
+    [System.Security.SecurityCriticalAttribute]
+    protected ClaimsPrincipal(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public ClaimsPrincipal(System.Security.Principal.IIdentity identity) { }
+    public ClaimsPrincipal(System.Security.Principal.IPrincipal principal) { }
+    public virtual System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> Claims { get { return default(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>); } }
+    public static System.Func<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalSelector { get { return default(System.Func<System.Security.Claims.ClaimsPrincipal>); } [System.Security.SecurityCriticalAttribute]set { } }
+    public static System.Security.Claims.ClaimsPrincipal Current { get { return default(System.Security.Claims.ClaimsPrincipal); } }
+    public virtual System.Collections.Generic.IEnumerable<System.Security.Claims.ClaimsIdentity> Identities { get { return default(System.Collections.Generic.IEnumerable<System.Security.Claims.ClaimsIdentity>); } }
+    public virtual System.Security.Principal.IIdentity Identity { get { return default(System.Security.Principal.IIdentity); } }
+    public static System.Func<System.Collections.Generic.IEnumerable<System.Security.Claims.ClaimsIdentity>, System.Security.Claims.ClaimsIdentity> PrimaryIdentitySelector { get { return default(System.Func<System.Collections.Generic.IEnumerable<System.Security.Claims.ClaimsIdentity>, System.Security.Claims.ClaimsIdentity>); } [System.Security.SecurityCriticalAttribute]set { } }
+    [System.Security.SecurityCriticalAttribute]
+    public virtual void AddIdentities(System.Collections.Generic.IEnumerable<System.Security.Claims.ClaimsIdentity> identities) { }
+    [System.Security.SecurityCriticalAttribute]
+    public virtual void AddIdentity(System.Security.Claims.ClaimsIdentity identity) { }
+    public virtual System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> FindAll(System.Predicate<System.Security.Claims.Claim> match) { return default(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>); }
+    public virtual System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> FindAll(string type) { return default(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>); }
+    public virtual System.Security.Claims.Claim FindFirst(System.Predicate<System.Security.Claims.Claim> match) { return default(System.Security.Claims.Claim); }
+    public virtual System.Security.Claims.Claim FindFirst(string type) { return default(System.Security.Claims.Claim); }
+    [System.Security.SecurityCriticalAttribute]
+    protected virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public virtual bool HasClaim(System.Predicate<System.Security.Claims.Claim> match) { return default(bool); }
+    public virtual bool HasClaim(string type, string value) { return default(bool); }
+    public virtual bool IsInRole(string role) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public static partial class ClaimTypes {
+    public const string Actor = "http://schemas.xmlsoap.org/ws/2009/09/identity/claims/actor";
+    public const string Anonymous = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/anonymous";
+    public const string Authentication = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/authentication";
+    public const string AuthenticationInstant = "http://schemas.microsoft.com/ws/2008/06/identity/claims/authenticationinstant";
+    public const string AuthenticationMethod = "http://schemas.microsoft.com/ws/2008/06/identity/claims/authenticationmethod";
+    public const string AuthorizationDecision = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/authorizationdecision";
+    public const string CookiePath = "http://schemas.microsoft.com/ws/2008/06/identity/claims/cookiepath";
+    public const string Country = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/country";
+    public const string DateOfBirth = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/dateofbirth";
+    public const string DenyOnlyPrimaryGroupSid = "http://schemas.microsoft.com/ws/2008/06/identity/claims/denyonlyprimarygroupsid";
+    public const string DenyOnlyPrimarySid = "http://schemas.microsoft.com/ws/2008/06/identity/claims/denyonlyprimarysid";
+    public const string DenyOnlySid = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/denyonlysid";
+    public const string DenyOnlyWindowsDeviceGroup = "http://schemas.microsoft.com/ws/2008/06/identity/claims/denyonlywindowsdevicegroup";
+    public const string Dns = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/dns";
+    public const string Dsa = "http://schemas.microsoft.com/ws/2008/06/identity/claims/dsa";
+    public const string Email = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress";
+    public const string Expiration = "http://schemas.microsoft.com/ws/2008/06/identity/claims/expiration";
+    public const string Expired = "http://schemas.microsoft.com/ws/2008/06/identity/claims/expired";
+    public const string Gender = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/gender";
+    public const string GivenName = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname";
+    public const string GroupSid = "http://schemas.microsoft.com/ws/2008/06/identity/claims/groupsid";
+    public const string Hash = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/hash";
+    public const string HomePhone = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/homephone";
+    public const string IsPersistent = "http://schemas.microsoft.com/ws/2008/06/identity/claims/ispersistent";
+    public const string Locality = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/locality";
+    public const string MobilePhone = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/mobilephone";
+    public const string Name = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name";
+    public const string NameIdentifier = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier";
+    public const string OtherPhone = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/otherphone";
+    public const string PostalCode = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/postalcode";
+    public const string PrimaryGroupSid = "http://schemas.microsoft.com/ws/2008/06/identity/claims/primarygroupsid";
+    public const string PrimarySid = "http://schemas.microsoft.com/ws/2008/06/identity/claims/primarysid";
+    public const string Role = "http://schemas.microsoft.com/ws/2008/06/identity/claims/role";
+    public const string Rsa = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/rsa";
+    public const string SerialNumber = "http://schemas.microsoft.com/ws/2008/06/identity/claims/serialnumber";
+    public const string Sid = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/sid";
+    public const string Spn = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/spn";
+    public const string StateOrProvince = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/stateorprovince";
+    public const string StreetAddress = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/streetaddress";
+    public const string Surname = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname";
+    public const string System = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/system";
+    public const string Thumbprint = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/thumbprint";
+    public const string Upn = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn";
+    public const string Uri = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/uri";
+    public const string UserData = "http://schemas.microsoft.com/ws/2008/06/identity/claims/userdata";
+    public const string Version = "http://schemas.microsoft.com/ws/2008/06/identity/claims/version";
+    public const string Webpage = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/webpage";
+    public const string WindowsAccountName = "http://schemas.microsoft.com/ws/2008/06/identity/claims/windowsaccountname";
+    public const string WindowsDeviceClaim = "http://schemas.microsoft.com/ws/2008/06/identity/claims/windowsdeviceclaim";
+    public const string WindowsDeviceGroup = "http://schemas.microsoft.com/ws/2008/06/identity/claims/windowsdevicegroup";
+    public const string WindowsFqbnVersion = "http://schemas.microsoft.com/ws/2008/06/identity/claims/windowsfqbnversion";
+    public const string WindowsSubAuthority = "http://schemas.microsoft.com/ws/2008/06/identity/claims/windowssubauthority";
+    public const string WindowsUserClaim = "http://schemas.microsoft.com/ws/2008/06/identity/claims/windowsuserclaim";
+    public const string X500DistinguishedName = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/x500distinguishedname";
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public static partial class ClaimValueTypes {
+    public const string Base64Binary = "http://www.w3.org/2001/XMLSchema#base64Binary";
+    public const string Base64Octet = "http://www.w3.org/2001/XMLSchema#base64Octet";
+    public const string Boolean = "http://www.w3.org/2001/XMLSchema#boolean";
+    public const string Date = "http://www.w3.org/2001/XMLSchema#date";
+    public const string DateTime = "http://www.w3.org/2001/XMLSchema#dateTime";
+    public const string DaytimeDuration = "http://www.w3.org/TR/2002/WD-xquery-operators-20020816#dayTimeDuration";
+    public const string DnsName = "http://schemas.xmlsoap.org/claims/dns";
+    public const string Double = "http://www.w3.org/2001/XMLSchema#double";
+    public const string DsaKeyValue = "http://www.w3.org/2000/09/xmldsig#DSAKeyValue";
+    public const string Email = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress";
+    public const string Fqbn = "http://www.w3.org/2001/XMLSchema#fqbn";
+    public const string HexBinary = "http://www.w3.org/2001/XMLSchema#hexBinary";
+    public const string Integer = "http://www.w3.org/2001/XMLSchema#integer";
+    public const string Integer32 = "http://www.w3.org/2001/XMLSchema#integer32";
+    public const string Integer64 = "http://www.w3.org/2001/XMLSchema#integer64";
+    public const string KeyInfo = "http://www.w3.org/2000/09/xmldsig#KeyInfo";
+    public const string Rfc822Name = "urn:oasis:names:tc:xacml:1.0:data-type:rfc822Name";
+    public const string Rsa = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/rsa";
+    public const string RsaKeyValue = "http://www.w3.org/2000/09/xmldsig#RSAKeyValue";
+    public const string Sid = "http://www.w3.org/2001/XMLSchema#sid";
+    public const string String = "http://www.w3.org/2001/XMLSchema#string";
+    public const string Time = "http://www.w3.org/2001/XMLSchema#time";
+    public const string UInteger32 = "http://www.w3.org/2001/XMLSchema#uinteger32";
+    public const string UInteger64 = "http://www.w3.org/2001/XMLSchema#uinteger64";
+    public const string UpnName = "http://schemas.xmlsoap.org/claims/UPN";
+    public const string X500Name = "urn:oasis:names:tc:xacml:1.0:data-type:x500Name";
+    public const string YearMonthDuration = "http://www.w3.org/TR/2002/WD-xquery-operators-20020816#yearMonthDuration";
+  }
+
+} // end of System.Security.Claims
+namespace System.Security.Principal {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class GenericIdentity : System.Security.Claims.ClaimsIdentity {
+    protected GenericIdentity(System.Security.Principal.GenericIdentity identity) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public GenericIdentity(string name) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public GenericIdentity(string name, string type) { }
+    public override string AuthenticationType { get { return default(string); } }
+    public override System.Collections.Generic.IEnumerable<System.Security.Claims.Claim> Claims { get { return default(System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>); } }
+    public override bool IsAuthenticated { get { return default(bool); } }
+    public override string Name { get { return default(string); } }
+    public override System.Security.Claims.ClaimsIdentity Clone() { return default(System.Security.Claims.ClaimsIdentity); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class GenericPrincipal : System.Security.Claims.ClaimsPrincipal {
+    public GenericPrincipal(System.Security.Principal.IIdentity identity, string[] roles) { }
+    public override System.Security.Principal.IIdentity Identity { get { return default(System.Security.Principal.IIdentity); } }
+    public override bool IsInRole(string role) { return default(bool); }
+  }
+
+} // end of System.Security.Principal

fxdac/fxdac/Data/Contracts/System.Security.Cryptography.Algorithms.cs

@@ -0,0 +1,467 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Cryptography {
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")]
+  public abstract partial class Aes : System.Security.Cryptography.SymmetricAlgorithm {
+    protected Aes() { }
+    public static new System.Security.Cryptography.Aes Create() { return default(System.Security.Cryptography.Aes); }
+    public static new System.Security.Cryptography.Aes Create(string algorithmName) { return default(System.Security.Cryptography.Aes); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class AsymmetricKeyExchangeDeformatter {
+    protected AsymmetricKeyExchangeDeformatter() { }
+    public abstract string Parameters { get; set; }
+    public abstract byte[] DecryptKeyExchange(byte[] rgb);
+    public abstract void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class AsymmetricKeyExchangeFormatter {
+    protected AsymmetricKeyExchangeFormatter() { }
+    public abstract string Parameters { get; }
+    public abstract byte[] CreateKeyExchange(byte[] data);
+    public abstract byte[] CreateKeyExchange(byte[] data, System.Type symAlgType);
+    public abstract void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class AsymmetricSignatureDeformatter {
+    protected AsymmetricSignatureDeformatter() { }
+    public abstract void SetHashAlgorithm(string strName);
+    public abstract void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key);
+    public abstract bool VerifySignature(byte[] rgbHash, byte[] rgbSignature);
+    public virtual bool VerifySignature(System.Security.Cryptography.HashAlgorithm hash, byte[] rgbSignature) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class AsymmetricSignatureFormatter {
+    protected AsymmetricSignatureFormatter() { }
+    public abstract byte[] CreateSignature(byte[] rgbHash);
+    public virtual byte[] CreateSignature(System.Security.Cryptography.HashAlgorithm hash) { return default(byte[]); }
+    public abstract void SetHashAlgorithm(string strName);
+    public abstract void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class DeriveBytes : System.IDisposable {
+    protected DeriveBytes() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public abstract byte[] GetBytes(int cb);
+    public abstract void Reset();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class DES : System.Security.Cryptography.SymmetricAlgorithm {
+    protected DES() { }
+    public override byte[] Key { get { return default(byte[]); } set { } }
+    public static new System.Security.Cryptography.DES Create() { return default(System.Security.Cryptography.DES); }
+    public static new System.Security.Cryptography.DES Create(string algName) { return default(System.Security.Cryptography.DES); }
+    public static bool IsSemiWeakKey(byte[] rgbKey) { return default(bool); }
+    public static bool IsWeakKey(byte[] rgbKey) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class DSA : System.Security.Cryptography.AsymmetricAlgorithm {
+    protected DSA() { }
+    public static new System.Security.Cryptography.DSA Create() { return default(System.Security.Cryptography.DSA); }
+    public static new System.Security.Cryptography.DSA Create(string algName) { return default(System.Security.Cryptography.DSA); }
+    public abstract byte[] CreateSignature(byte[] rgbHash);
+    public abstract System.Security.Cryptography.DSAParameters ExportParameters(bool includePrivateParameters);
+    public override void FromXmlString(string xmlString) { }
+    public abstract void ImportParameters(System.Security.Cryptography.DSAParameters parameters);
+    public override string ToXmlString(bool includePrivateParameters) { return default(string); }
+    public abstract bool VerifySignature(byte[] rgbHash, byte[] rgbSignature);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct DSAParameters {
+    public int Counter;
+    public byte[] G;
+    public byte[] J;
+    public byte[] P;
+    public byte[] Q;
+    public byte[] Seed;
+    public byte[] X;
+    public byte[] Y;
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class DSASignatureDeformatter : System.Security.Cryptography.AsymmetricSignatureDeformatter {
+    public DSASignatureDeformatter() { }
+    public DSASignatureDeformatter(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override void SetHashAlgorithm(string strName) { }
+    public override void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override bool VerifySignature(byte[] rgbHash, byte[] rgbSignature) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class DSASignatureFormatter : System.Security.Cryptography.AsymmetricSignatureFormatter {
+    public DSASignatureFormatter() { }
+    public DSASignatureFormatter(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override byte[] CreateSignature(byte[] rgbHash) { return default(byte[]); }
+    public override void SetHashAlgorithm(string strName) { }
+    public override void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HMACMD5 : System.Security.Cryptography.HMAC {
+    public HMACMD5() { }
+    public HMACMD5(byte[] key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HMACRIPEMD160 : System.Security.Cryptography.HMAC {
+    public HMACRIPEMD160() { }
+    public HMACRIPEMD160(byte[] key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HMACSHA1 : System.Security.Cryptography.HMAC {
+    public HMACSHA1() { }
+    public HMACSHA1(byte[] key) { }
+    public HMACSHA1(byte[] key, bool useManagedSha1) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HMACSHA256 : System.Security.Cryptography.HMAC {
+    public HMACSHA256() { }
+    public HMACSHA256(byte[] key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HMACSHA384 : System.Security.Cryptography.HMAC {
+    public HMACSHA384() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public HMACSHA384(byte[] key) { }
+    public bool ProduceLegacyHmacValues { get { return default(bool); } set { } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HMACSHA512 : System.Security.Cryptography.HMAC {
+    public HMACSHA512() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public HMACSHA512(byte[] key) { }
+    public bool ProduceLegacyHmacValues { get { return default(bool); } set { } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class MACTripleDES : System.Security.Cryptography.KeyedHashAlgorithm {
+    public MACTripleDES() { }
+    public MACTripleDES(byte[] rgbKey) { }
+    public MACTripleDES(string strTripleDES, byte[] rgbKey) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Security.Cryptography.PaddingMode Padding { get { return default(System.Security.Cryptography.PaddingMode); } set { } }
+    protected override void Dispose(bool disposing) { }
+    protected override void HashCore(byte[] rgbData, int ibStart, int cbSize) { }
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class MD5 : System.Security.Cryptography.HashAlgorithm {
+    protected MD5() { }
+    public static new System.Security.Cryptography.MD5 Create() { return default(System.Security.Cryptography.MD5); }
+    public static new System.Security.Cryptography.MD5 Create(string algName) { return default(System.Security.Cryptography.MD5); }
+  }
+
+  public sealed partial class MD5CryptoServiceProvider : System.Security.Cryptography.MD5 {
+    public MD5CryptoServiceProvider() { }
+    protected override void Dispose(bool disposing) { }
+    ~MD5CryptoServiceProvider() { }
+    protected override void HashCore(byte[] data, int start, int length) { }
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class RandomNumberGenerator : System.IDisposable {
+    protected RandomNumberGenerator() { }
+    public static System.Security.Cryptography.RandomNumberGenerator Create() { return default(System.Security.Cryptography.RandomNumberGenerator); }
+    public static System.Security.Cryptography.RandomNumberGenerator Create(string rngName) { return default(System.Security.Cryptography.RandomNumberGenerator); }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public abstract void GetBytes(byte[] data);
+    public virtual void GetNonZeroBytes(byte[] data) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class RC2 : System.Security.Cryptography.SymmetricAlgorithm {
+    protected int EffectiveKeySizeValue;
+    protected RC2() { }
+    public virtual int EffectiveKeySize { get { return default(int); } set { } }
+    public override int KeySize { get { return default(int); } set { } }
+    public static new System.Security.Cryptography.RC2 Create() { return default(System.Security.Cryptography.RC2); }
+    public static new System.Security.Cryptography.RC2 Create(string AlgName) { return default(System.Security.Cryptography.RC2); }
+  }
+
+  public sealed partial class RC2CryptoServiceProvider : System.Security.Cryptography.RC2 {
+    public RC2CryptoServiceProvider() { }
+    public override int EffectiveKeySize { get { return default(int); } set { } }
+    public override System.Security.Cryptography.ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override System.Security.Cryptography.ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override void GenerateIV() { }
+    public override void GenerateKey() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class Rfc2898DeriveBytes : System.Security.Cryptography.DeriveBytes {
+    public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations) { }
+    public Rfc2898DeriveBytes(string password, byte[] salt) { }
+    public Rfc2898DeriveBytes(string password, byte[] salt, int iterations) { }
+    public Rfc2898DeriveBytes(string password, int saltSize) { }
+    public Rfc2898DeriveBytes(string password, int saltSize, int iterations) { }
+    public int IterationCount { get { return default(int); } set { } }
+    public byte[] Salt { get { return default(byte[]); } set { } }
+    protected override void Dispose(bool disposing) { }
+    public override byte[] GetBytes(int cb) { return default(byte[]); }
+    public override void Reset() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class Rijndael : System.Security.Cryptography.SymmetricAlgorithm {
+    protected Rijndael() { }
+    public static new System.Security.Cryptography.Rijndael Create() { return default(System.Security.Cryptography.Rijndael); }
+    public static new System.Security.Cryptography.Rijndael Create(string algName) { return default(System.Security.Cryptography.Rijndael); }
+  }
+
+  public sealed partial class RijndaelManaged : System.Security.Cryptography.Rijndael {
+    public RijndaelManaged() { }
+    public override System.Security.Cryptography.ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override System.Security.Cryptography.ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override void GenerateIV() { }
+    public override void GenerateKey() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class RijndaelManagedTransform : System.IDisposable, System.Security.Cryptography.ICryptoTransform {
+    internal RijndaelManagedTransform() { }
+    public int BlockSizeValue { get { return default(int); } }
+    public bool CanReuseTransform { get { return default(bool); } }
+    public bool CanTransformMultipleBlocks { get { return default(bool); } }
+    public int InputBlockSize { get { return default(int); } }
+    public int OutputBlockSize { get { return default(int); } }
+    public void Clear() { }
+    public void Dispose() { }
+    public void Reset() { }
+    public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) { return default(int); }
+    public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { return default(byte[]); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class RIPEMD160 : System.Security.Cryptography.HashAlgorithm {
+    protected RIPEMD160() { }
+    public static new System.Security.Cryptography.RIPEMD160 Create() { return default(System.Security.Cryptography.RIPEMD160); }
+    public static new System.Security.Cryptography.RIPEMD160 Create(string hashName) { return default(System.Security.Cryptography.RIPEMD160); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class RIPEMD160Managed : System.Security.Cryptography.RIPEMD160 {
+    public RIPEMD160Managed() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected override void HashCore(byte[] rgb, int ibStart, int cbSize) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  public partial class RNGCryptoServiceProvider : System.Security.Cryptography.RandomNumberGenerator {
+    public RNGCryptoServiceProvider() { }
+    ~RNGCryptoServiceProvider() { }
+    public override void GetBytes(byte[] data) { }
+    public override void GetNonZeroBytes(byte[] data) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class RSA : System.Security.Cryptography.AsymmetricAlgorithm {
+    protected RSA() { }
+    public static new System.Security.Cryptography.RSA Create() { return default(System.Security.Cryptography.RSA); }
+    public static new System.Security.Cryptography.RSA Create(string algName) { return default(System.Security.Cryptography.RSA); }
+    public abstract byte[] DecryptValue(byte[] rgb);
+    public abstract byte[] EncryptValue(byte[] rgb);
+    public abstract System.Security.Cryptography.RSAParameters ExportParameters(bool includePrivateParameters);
+    public override void FromXmlString(string xmlString) { }
+    public abstract void ImportParameters(System.Security.Cryptography.RSAParameters parameters);
+    public override string ToXmlString(bool includePrivateParameters) { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class RSAOAEPKeyExchangeDeformatter : System.Security.Cryptography.AsymmetricKeyExchangeDeformatter {
+    public RSAOAEPKeyExchangeDeformatter() { }
+    public RSAOAEPKeyExchangeDeformatter(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override string Parameters { get { return default(string); } set { } }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override byte[] DecryptKeyExchange(byte[] rgbData) { return default(byte[]); }
+    public override void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class RSAOAEPKeyExchangeFormatter : System.Security.Cryptography.AsymmetricKeyExchangeFormatter {
+    public RSAOAEPKeyExchangeFormatter() { }
+    public RSAOAEPKeyExchangeFormatter(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public byte[] Parameter { get { return default(byte[]); } set { } }
+    public override string Parameters { get { return default(string); } }
+    public System.Security.Cryptography.RandomNumberGenerator Rng { get { return default(System.Security.Cryptography.RandomNumberGenerator); } set { } }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override byte[] CreateKeyExchange(byte[] rgbData) { return default(byte[]); }
+    public override byte[] CreateKeyExchange(byte[] rgbData, System.Type symAlgType) { return default(byte[]); }
+    public override void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct RSAParameters {
+    public byte[] D;
+    public byte[] DP;
+    public byte[] DQ;
+    public byte[] Exponent;
+    public byte[] InverseQ;
+    public byte[] Modulus;
+    public byte[] P;
+    public byte[] Q;
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class RSAPKCS1KeyExchangeDeformatter : System.Security.Cryptography.AsymmetricKeyExchangeDeformatter {
+    public RSAPKCS1KeyExchangeDeformatter() { }
+    public RSAPKCS1KeyExchangeDeformatter(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override string Parameters { get { return default(string); } set { } }
+    public System.Security.Cryptography.RandomNumberGenerator RNG { get { return default(System.Security.Cryptography.RandomNumberGenerator); } set { } }
+    public override byte[] DecryptKeyExchange(byte[] rgbIn) { return default(byte[]); }
+    public override void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class RSAPKCS1KeyExchangeFormatter : System.Security.Cryptography.AsymmetricKeyExchangeFormatter {
+    public RSAPKCS1KeyExchangeFormatter() { }
+    public RSAPKCS1KeyExchangeFormatter(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override string Parameters { get { return default(string); } }
+    public System.Security.Cryptography.RandomNumberGenerator Rng { get { return default(System.Security.Cryptography.RandomNumberGenerator); } set { } }
+    public override byte[] CreateKeyExchange(byte[] rgbData) { return default(byte[]); }
+    public override byte[] CreateKeyExchange(byte[] rgbData, System.Type symAlgType) { return default(byte[]); }
+    public override void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class RSAPKCS1SignatureDeformatter : System.Security.Cryptography.AsymmetricSignatureDeformatter {
+    public RSAPKCS1SignatureDeformatter() { }
+    public RSAPKCS1SignatureDeformatter(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override void SetHashAlgorithm(string strName) { }
+    public override void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override bool VerifySignature(byte[] rgbHash, byte[] rgbSignature) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class RSAPKCS1SignatureFormatter : System.Security.Cryptography.AsymmetricSignatureFormatter {
+    public RSAPKCS1SignatureFormatter() { }
+    public RSAPKCS1SignatureFormatter(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+    public override byte[] CreateSignature(byte[] rgbHash) { return default(byte[]); }
+    public override void SetHashAlgorithm(string strName) { }
+    public override void SetKey(System.Security.Cryptography.AsymmetricAlgorithm key) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class SHA1 : System.Security.Cryptography.HashAlgorithm {
+    protected SHA1() { }
+    public static new System.Security.Cryptography.SHA1 Create() { return default(System.Security.Cryptography.SHA1); }
+    public static new System.Security.Cryptography.SHA1 Create(string hashName) { return default(System.Security.Cryptography.SHA1); }
+  }
+
+  public sealed partial class SHA1CryptoServiceProvider : System.Security.Cryptography.SHA1 {
+    public SHA1CryptoServiceProvider() { }
+    protected override void Dispose(bool disposing) { }
+    ~SHA1CryptoServiceProvider() { }
+    protected override void HashCore(byte[] data, int start, int length) { }
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  public sealed partial class SHA1Managed : System.Security.Cryptography.SHA1 {
+    public SHA1Managed() { }
+    protected override void Dispose(bool disposing) { }
+    ~SHA1Managed() { }
+    protected override void HashCore(byte[] data, int start, int length) { }
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class SHA256 : System.Security.Cryptography.HashAlgorithm {
+    protected SHA256() { }
+    public static new System.Security.Cryptography.SHA256 Create() { return default(System.Security.Cryptography.SHA256); }
+    public static new System.Security.Cryptography.SHA256 Create(string hashName) { return default(System.Security.Cryptography.SHA256); }
+  }
+
+  public sealed partial class SHA256Managed : System.Security.Cryptography.SHA256 {
+    public SHA256Managed() { }
+    protected override void Dispose(bool disposing) { }
+    ~SHA256Managed() { }
+    protected override void HashCore(byte[] data, int start, int length) { }
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class SHA384 : System.Security.Cryptography.HashAlgorithm {
+    protected SHA384() { }
+    public static new System.Security.Cryptography.SHA384 Create() { return default(System.Security.Cryptography.SHA384); }
+    public static new System.Security.Cryptography.SHA384 Create(string hashName) { return default(System.Security.Cryptography.SHA384); }
+  }
+
+  public sealed partial class SHA384Managed : System.Security.Cryptography.SHA384 {
+    public SHA384Managed() { }
+    protected override void Dispose(bool disposing) { }
+    ~SHA384Managed() { }
+    protected override void HashCore(byte[] data, int start, int length) { }
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class SHA512 : System.Security.Cryptography.HashAlgorithm {
+    protected SHA512() { }
+    public static new System.Security.Cryptography.SHA512 Create() { return default(System.Security.Cryptography.SHA512); }
+    public static new System.Security.Cryptography.SHA512 Create(string hashName) { return default(System.Security.Cryptography.SHA512); }
+  }
+
+  public sealed partial class SHA512Managed : System.Security.Cryptography.SHA512 {
+    public SHA512Managed() { }
+    protected override void Dispose(bool disposing) { }
+    ~SHA512Managed() { }
+    protected override void HashCore(byte[] data, int start, int length) { }
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class SignatureDescription {
+    public SignatureDescription() { }
+    public SignatureDescription(System.Security.SecurityElement el) { }
+    public string DeformatterAlgorithm { get { return default(string); } set { } }
+    public string DigestAlgorithm { get { return default(string); } set { } }
+    public string FormatterAlgorithm { get { return default(string); } set { } }
+    public string KeyAlgorithm { get { return default(string); } set { } }
+    public virtual System.Security.Cryptography.AsymmetricSignatureDeformatter CreateDeformatter(System.Security.Cryptography.AsymmetricAlgorithm key) { return default(System.Security.Cryptography.AsymmetricSignatureDeformatter); }
+    public virtual System.Security.Cryptography.HashAlgorithm CreateDigest() { return default(System.Security.Cryptography.HashAlgorithm); }
+    public virtual System.Security.Cryptography.AsymmetricSignatureFormatter CreateFormatter(System.Security.Cryptography.AsymmetricAlgorithm key) { return default(System.Security.Cryptography.AsymmetricSignatureFormatter); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class TripleDES : System.Security.Cryptography.SymmetricAlgorithm {
+    protected TripleDES() { }
+    public override byte[] Key { get { return default(byte[]); } set { } }
+    public static new System.Security.Cryptography.TripleDES Create() { return default(System.Security.Cryptography.TripleDES); }
+    public static new System.Security.Cryptography.TripleDES Create(string str) { return default(System.Security.Cryptography.TripleDES); }
+    public static bool IsWeakKey(byte[] rgbKey) { return default(bool); }
+  }
+
+  public sealed partial class TripleDESCryptoServiceProvider : System.Security.Cryptography.TripleDES {
+    public TripleDESCryptoServiceProvider() { }
+    public override System.Security.Cryptography.ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override System.Security.Cryptography.ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override void GenerateIV() { }
+    public override void GenerateKey() { }
+  }
+
+} // end of System.Security.Cryptography

fxdac/fxdac/Data/Contracts/System.Security.Cryptography.Csp.cs

@@ -0,0 +1,253 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Cryptography {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class CspKeyContainerInfo {
+    public CspKeyContainerInfo(System.Security.Cryptography.CspParameters parameters) { }
+    public bool Accessible { get { return default(bool); } }
+    public System.Security.AccessControl.CryptoKeySecurity CryptoKeySecurity { get { return default(System.Security.AccessControl.CryptoKeySecurity); } }
+    public bool Exportable { get { return default(bool); } }
+    public bool HardwareDevice { get { return default(bool); } }
+    public string KeyContainerName { get { return default(string); } }
+    public System.Security.Cryptography.KeyNumber KeyNumber { get { return default(System.Security.Cryptography.KeyNumber); } }
+    public bool MachineKeyStore { get { return default(bool); } }
+    public bool Protected { get { return default(bool); } }
+    public string ProviderName { get { return default(string); } }
+    public int ProviderType { get { return default(int); } }
+    public bool RandomlyGenerated { get { return default(bool); } }
+    public bool Removable { get { return default(bool); } }
+    public string UniqueKeyContainerName { get { return default(string); } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class CspParameters {
+    public string KeyContainerName;
+    public int KeyNumber;
+    public string ProviderName;
+    public int ProviderType;
+    public CspParameters() { }
+    public CspParameters(int dwTypeIn) { }
+    public CspParameters(int dwTypeIn, string strProviderNameIn) { }
+    public CspParameters(int dwTypeIn, string strProviderNameIn, string strContainerNameIn) { }
+    public CspParameters(int providerType, string providerName, string keyContainerName, System.Security.AccessControl.CryptoKeySecurity cryptoKeySecurity, System.IntPtr parentWindowHandle) { }
+    public CspParameters(int providerType, string providerName, string keyContainerName, System.Security.AccessControl.CryptoKeySecurity cryptoKeySecurity, System.Security.SecureString keyPassword) { }
+    public System.Security.AccessControl.CryptoKeySecurity CryptoKeySecurity { get { return default(System.Security.AccessControl.CryptoKeySecurity); } set { } }
+    public System.Security.Cryptography.CspProviderFlags Flags { get { return default(System.Security.Cryptography.CspProviderFlags); } set { } }
+    public System.Security.SecureString KeyPassword { get { return default(System.Security.SecureString); } set { } }
+    public System.IntPtr ParentWindowHandle { get { return default(System.IntPtr); } set { } }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum CspProviderFlags {
+    CreateEphemeralKey = 128,
+    NoFlags = 0,
+    NoPrompt = 64,
+    UseArchivableKey = 16,
+    UseDefaultKeyContainer = 2,
+    UseExistingKey = 8,
+    UseMachineKeyStore = 1,
+    UseNonExportableKey = 4,
+    UseUserProtectedKey = 32,
+  }
+
+  public sealed partial class DESCryptoServiceProvider : System.Security.Cryptography.DES {
+    public DESCryptoServiceProvider() { }
+    public override System.Security.Cryptography.ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override System.Security.Cryptography.ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override void GenerateIV() { }
+    public override void GenerateKey() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class DSACryptoServiceProvider : System.Security.Cryptography.DSA, System.Security.Cryptography.ICspAsymmetricAlgorithm {
+    public DSACryptoServiceProvider() { }
+    public DSACryptoServiceProvider(int dwKeySize) { }
+    public DSACryptoServiceProvider(int dwKeySize, System.Security.Cryptography.CspParameters parameters) { }
+    public DSACryptoServiceProvider(System.Security.Cryptography.CspParameters parameters) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Security.Cryptography.CspKeyContainerInfo CspKeyContainerInfo { get { return default(System.Security.Cryptography.CspKeyContainerInfo); } }
+    public override string KeyExchangeAlgorithm { get { return default(string); } }
+    public override int KeySize { get { return default(int); } }
+    public bool PersistKeyInCsp { get { return default(bool); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public bool PublicOnly { get { return default(bool); } }
+    public override string SignatureAlgorithm { get { return default(string); } }
+    public static bool UseMachineKeyStore { get { return default(bool); } set { } }
+    public override byte[] CreateSignature(byte[] rgbHash) { return default(byte[]); }
+    protected override void Dispose(bool disposing) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public byte[] ExportCspBlob(bool includePrivateParameters) { return default(byte[]); }
+    public override System.Security.Cryptography.DSAParameters ExportParameters(bool includePrivateParameters) { return default(System.Security.Cryptography.DSAParameters); }
+    ~DSACryptoServiceProvider() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void ImportCspBlob(byte[] keyBlob) { }
+    public override void ImportParameters(System.Security.Cryptography.DSAParameters parameters) { }
+    public byte[] SignData(byte[] buffer) { return default(byte[]); }
+    public byte[] SignData(byte[] buffer, int offset, int count) { return default(byte[]); }
+    public byte[] SignData(System.IO.Stream inputStream) { return default(byte[]); }
+    public byte[] SignHash(byte[] rgbHash, string str) { return default(byte[]); }
+    public bool VerifyData(byte[] rgbData, byte[] rgbSignature) { return default(bool); }
+    public bool VerifyHash(byte[] rgbHash, string str, byte[] rgbSignature) { return default(bool); }
+    public override bool VerifySignature(byte[] rgbHash, byte[] rgbSignature) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ICspAsymmetricAlgorithm {
+    System.Security.Cryptography.CspKeyContainerInfo CspKeyContainerInfo { get; }
+    byte[] ExportCspBlob(bool includePrivateParameters);
+    void ImportCspBlob(byte[] rawData);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum KeyNumber {
+    Exchange = 1,
+    Signature = 2,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class PasswordDeriveBytes : System.Security.Cryptography.DeriveBytes {
+    public PasswordDeriveBytes(byte[] password, byte[] salt) { }
+    public PasswordDeriveBytes(byte[] password, byte[] salt, System.Security.Cryptography.CspParameters cspParams) { }
+    public PasswordDeriveBytes(byte[] password, byte[] salt, string hashName, int iterations) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public PasswordDeriveBytes(byte[] password, byte[] salt, string hashName, int iterations, System.Security.Cryptography.CspParameters cspParams) { }
+    public PasswordDeriveBytes(string strPassword, byte[] rgbSalt) { }
+    public PasswordDeriveBytes(string strPassword, byte[] rgbSalt, System.Security.Cryptography.CspParameters cspParams) { }
+    public PasswordDeriveBytes(string strPassword, byte[] rgbSalt, string strHashName, int iterations) { }
+    public PasswordDeriveBytes(string strPassword, byte[] rgbSalt, string strHashName, int iterations, System.Security.Cryptography.CspParameters cspParams) { }
+    public string HashName { get { return default(string); } set { } }
+    public int IterationCount { get { return default(int); } set { } }
+    public byte[] Salt { get { return default(byte[]); } set { } }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public byte[] CryptDeriveKey(string algname, string alghashname, int keySize, byte[] rgbIV) { return default(byte[]); }
+    protected override void Dispose(bool disposing) { }
+    [System.ObsoleteAttribute("Rfc2898DeriveBytes replaces PasswordDeriveBytes for deriving key material from a password and is preferred in new applications.")]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override byte[] GetBytes(int cb) { return default(byte[]); }
+    public override void Reset() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class RSACryptoServiceProvider : System.Security.Cryptography.RSA, System.Security.Cryptography.ICspAsymmetricAlgorithm {
+    public RSACryptoServiceProvider() { }
+    public RSACryptoServiceProvider(int dwKeySize) { }
+    public RSACryptoServiceProvider(int dwKeySize, System.Security.Cryptography.CspParameters parameters) { }
+    public RSACryptoServiceProvider(System.Security.Cryptography.CspParameters parameters) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Security.Cryptography.CspKeyContainerInfo CspKeyContainerInfo { get { return default(System.Security.Cryptography.CspKeyContainerInfo); } }
+    public override string KeyExchangeAlgorithm { get { return default(string); } }
+    public override int KeySize { get { return default(int); } }
+    public bool PersistKeyInCsp { get { return default(bool); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public bool PublicOnly { get { return default(bool); } }
+    public override string SignatureAlgorithm { get { return default(string); } }
+    public static bool UseMachineKeyStore { get { return default(bool); } set { } }
+    public byte[] Decrypt(byte[] rgb, bool fOAEP) { return default(byte[]); }
+    public override byte[] DecryptValue(byte[] rgb) { return default(byte[]); }
+    protected override void Dispose(bool disposing) { }
+    public byte[] Encrypt(byte[] rgb, bool fOAEP) { return default(byte[]); }
+    public override byte[] EncryptValue(byte[] rgb) { return default(byte[]); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public byte[] ExportCspBlob(bool includePrivateParameters) { return default(byte[]); }
+    public override System.Security.Cryptography.RSAParameters ExportParameters(bool includePrivateParameters) { return default(System.Security.Cryptography.RSAParameters); }
+    ~RSACryptoServiceProvider() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void ImportCspBlob(byte[] keyBlob) { }
+    public override void ImportParameters(System.Security.Cryptography.RSAParameters parameters) { }
+    public byte[] SignData(byte[] buffer, int offset, int count, object halg) { return default(byte[]); }
+    public byte[] SignData(byte[] buffer, object halg) { return default(byte[]); }
+    public byte[] SignData(System.IO.Stream inputStream, object halg) { return default(byte[]); }
+    public byte[] SignHash(byte[] rgbHash, string str) { return default(byte[]); }
+    public bool VerifyData(byte[] buffer, object halg, byte[] signature) { return default(bool); }
+    public bool VerifyHash(byte[] rgbHash, string str, byte[] rgbSignature) { return default(bool); }
+  }
+
+} // end of System.Security.Cryptography
+namespace System.Security.Permissions {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class KeyContainerPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public KeyContainerPermission(System.Security.Permissions.KeyContainerPermissionFlags flags) { }
+    public KeyContainerPermission(System.Security.Permissions.KeyContainerPermissionFlags flags, System.Security.Permissions.KeyContainerPermissionAccessEntry[] accessList) { }
+    public KeyContainerPermission(System.Security.Permissions.PermissionState state) { }
+    public System.Security.Permissions.KeyContainerPermissionAccessEntryCollection AccessEntries { get { return default(System.Security.Permissions.KeyContainerPermissionAccessEntryCollection); } }
+    public System.Security.Permissions.KeyContainerPermissionFlags Flags { get { return default(System.Security.Permissions.KeyContainerPermissionFlags); } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement securityElement) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class KeyContainerPermissionAccessEntry {
+    public KeyContainerPermissionAccessEntry(System.Security.Cryptography.CspParameters parameters, System.Security.Permissions.KeyContainerPermissionFlags flags) { }
+    public KeyContainerPermissionAccessEntry(string keyContainerName, System.Security.Permissions.KeyContainerPermissionFlags flags) { }
+    public KeyContainerPermissionAccessEntry(string keyStore, string providerName, int providerType, string keyContainerName, int keySpec, System.Security.Permissions.KeyContainerPermissionFlags flags) { }
+    public System.Security.Permissions.KeyContainerPermissionFlags Flags { get { return default(System.Security.Permissions.KeyContainerPermissionFlags); } set { } }
+    public string KeyContainerName { get { return default(string); } set { } }
+    public int KeySpec { get { return default(int); } set { } }
+    public string KeyStore { get { return default(string); } set { } }
+    public string ProviderName { get { return default(string); } set { } }
+    public int ProviderType { get { return default(int); } set { } }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class KeyContainerPermissionAccessEntryCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    internal KeyContainerPermissionAccessEntryCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Security.Permissions.KeyContainerPermissionAccessEntry this[int index] { get { return default(System.Security.Permissions.KeyContainerPermissionAccessEntry); } }
+    public object SyncRoot { get { return default(object); } }
+    public int Add(System.Security.Permissions.KeyContainerPermissionAccessEntry accessEntry) { return default(int); }
+    public void Clear() { }
+    public void CopyTo(System.Security.Permissions.KeyContainerPermissionAccessEntry[] array, int index) { }
+    public System.Security.Permissions.KeyContainerPermissionAccessEntryEnumerator GetEnumerator() { return default(System.Security.Permissions.KeyContainerPermissionAccessEntryEnumerator); }
+    public int IndexOf(System.Security.Permissions.KeyContainerPermissionAccessEntry accessEntry) { return default(int); }
+    public void Remove(System.Security.Permissions.KeyContainerPermissionAccessEntry accessEntry) { }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class KeyContainerPermissionAccessEntryEnumerator : System.Collections.IEnumerator {
+    internal KeyContainerPermissionAccessEntryEnumerator() { }
+    public System.Security.Permissions.KeyContainerPermissionAccessEntry Current { get { return default(System.Security.Permissions.KeyContainerPermissionAccessEntry); } }
+    object System.Collections.IEnumerator.Current { get { return default(object); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class KeyContainerPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public KeyContainerPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public System.Security.Permissions.KeyContainerPermissionFlags Flags { get { return default(System.Security.Permissions.KeyContainerPermissionFlags); } set { } }
+    public string KeyContainerName { get { return default(string); } set { } }
+    public int KeySpec { get { return default(int); } set { } }
+    public string KeyStore { get { return default(string); } set { } }
+    public string ProviderName { get { return default(string); } set { } }
+    public int ProviderType { get { return default(int); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum KeyContainerPermissionFlags {
+    AllFlags = 13111,
+    ChangeAcl = 8192,
+    Create = 1,
+    Decrypt = 512,
+    Delete = 4,
+    Export = 32,
+    Import = 16,
+    NoFlags = 0,
+    Open = 2,
+    Sign = 256,
+    ViewAcl = 4096,
+  }
+
+} // end of System.Security.Permissions

fxdac/fxdac/Data/Contracts/System.Security.Cryptography.Encoding.cs

@@ -0,0 +1,69 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Cryptography {
+  public partial class AsnEncodedData {
+    protected AsnEncodedData() { }
+    public AsnEncodedData(byte[] rawData) { }
+    public AsnEncodedData(System.Security.Cryptography.AsnEncodedData asnEncodedData) { }
+    public AsnEncodedData(System.Security.Cryptography.Oid oid, byte[] rawData) { }
+    public AsnEncodedData(string oid, byte[] rawData) { }
+    public System.Security.Cryptography.Oid Oid { get { return default(System.Security.Cryptography.Oid); } set { } }
+    public byte[] RawData { get { return default(byte[]); } set { } }
+    public virtual void CopyFrom(System.Security.Cryptography.AsnEncodedData asnEncodedData) { }
+    public virtual string Format(bool multiLine) { return default(string); }
+  }
+
+  public sealed partial class AsnEncodedDataCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    public AsnEncodedDataCollection() { }
+    public AsnEncodedDataCollection(System.Security.Cryptography.AsnEncodedData asnEncodedData) { }
+    public int Count { get { return default(int); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Security.Cryptography.AsnEncodedData this[int index] { get { return default(System.Security.Cryptography.AsnEncodedData); } }
+    public object SyncRoot { get { return default(object); } }
+    public int Add(System.Security.Cryptography.AsnEncodedData asnEncodedData) { return default(int); }
+    public void CopyTo(System.Security.Cryptography.AsnEncodedData[] array, int index) { }
+    public System.Security.Cryptography.AsnEncodedDataEnumerator GetEnumerator() { return default(System.Security.Cryptography.AsnEncodedDataEnumerator); }
+    public void Remove(System.Security.Cryptography.AsnEncodedData asnEncodedData) { }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public sealed partial class AsnEncodedDataEnumerator : System.Collections.IEnumerator {
+    internal AsnEncodedDataEnumerator() { }
+    public System.Security.Cryptography.AsnEncodedData Current { get { return default(System.Security.Cryptography.AsnEncodedData); } }
+    object System.Collections.IEnumerator.Current { get { return default(object); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+  public sealed partial class Oid {
+    public Oid() { }
+    public Oid(System.Security.Cryptography.Oid oid) { }
+    public Oid(string oid) { }
+    public Oid(string value, string friendlyName) { }
+    public string FriendlyName { get { return default(string); } set { } }
+    public string Value { get { return default(string); } set { } }
+  }
+
+  public sealed partial class OidCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    public OidCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Security.Cryptography.Oid this[int index] { get { return default(System.Security.Cryptography.Oid); } }
+    public System.Security.Cryptography.Oid this[string oid] { get { return default(System.Security.Cryptography.Oid); } }
+    public object SyncRoot { get { return default(object); } }
+    public int Add(System.Security.Cryptography.Oid oid) { return default(int); }
+    public void CopyTo(System.Security.Cryptography.Oid[] array, int index) { }
+    public System.Security.Cryptography.OidEnumerator GetEnumerator() { return default(System.Security.Cryptography.OidEnumerator); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public sealed partial class OidEnumerator : System.Collections.IEnumerator {
+    internal OidEnumerator() { }
+    public System.Security.Cryptography.Oid Current { get { return default(System.Security.Cryptography.Oid); } }
+    object System.Collections.IEnumerator.Current { get { return default(object); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+} // end of System.Security.Cryptography

fxdac/fxdac/Data/Contracts/System.Security.Cryptography.Primitives.cs

@@ -0,0 +1,191 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Cryptography {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class AsymmetricAlgorithm : System.IDisposable {
+    protected int KeySizeValue;
+    protected System.Security.Cryptography.KeySizes[] LegalKeySizesValue;
+    protected AsymmetricAlgorithm() { }
+    public abstract string KeyExchangeAlgorithm { get; }
+    public virtual int KeySize { get { return default(int); } set { } }
+    public virtual System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
+    public abstract string SignatureAlgorithm { get; }
+    public void Clear() { }
+    public static System.Security.Cryptography.AsymmetricAlgorithm Create() { return default(System.Security.Cryptography.AsymmetricAlgorithm); }
+    public static System.Security.Cryptography.AsymmetricAlgorithm Create(string algName) { return default(System.Security.Cryptography.AsymmetricAlgorithm); }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public abstract void FromXmlString(string xmlString);
+    public abstract string ToXmlString(bool includePrivateParameters);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum CipherMode {
+    CBC = 1,
+    CFB = 4,
+    CTS = 5,
+    ECB = 2,
+    OFB = 3,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class CryptographicException : System.SystemException {
+    public CryptographicException() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public CryptographicException(int hr) { }
+    protected CryptographicException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public CryptographicException(string message) { }
+    public CryptographicException(string message, System.Exception inner) { }
+    public CryptographicException(string format, string insert) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class CryptographicUnexpectedOperationException : System.Security.Cryptography.CryptographicException {
+    public CryptographicUnexpectedOperationException() { }
+    protected CryptographicUnexpectedOperationException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public CryptographicUnexpectedOperationException(string message) { }
+    public CryptographicUnexpectedOperationException(string message, System.Exception inner) { }
+    public CryptographicUnexpectedOperationException(string format, string insert) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class CryptoStream : System.IO.Stream, System.IDisposable {
+    public CryptoStream(System.IO.Stream stream, System.Security.Cryptography.ICryptoTransform transform, System.Security.Cryptography.CryptoStreamMode mode) { }
+    public override bool CanRead { get { return default(bool); } }
+    public override bool CanSeek { get { return default(bool); } }
+    public override bool CanWrite { get { return default(bool); } }
+    public bool HasFlushedFinalBlock { get { return default(bool); } }
+    public override long Length { get { return default(long); } }
+    public override long Position { get { return default(long); } set { } }
+    public void Clear() { }
+    protected override void Dispose(bool disposing) { }
+    public override void Flush() { }
+    public override System.Threading.Tasks.Task FlushAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    public void FlushFinalBlock() { }
+    public override int Read(byte[] buffer, int offset, int count) { buffer = default(byte[]); return default(int); }
+    public override System.Threading.Tasks.Task<int> ReadAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<int>); }
+    public override long Seek(long offset, System.IO.SeekOrigin origin) { return default(long); }
+    public override void SetLength(long value) { }
+    public override void Write(byte[] buffer, int offset, int count) { }
+    public override System.Threading.Tasks.Task WriteAsync(byte[] buffer, int offset, int count, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum CryptoStreamMode {
+    Read = 0,
+    Write = 1,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class HashAlgorithm : System.IDisposable, System.Security.Cryptography.ICryptoTransform {
+    protected int HashSizeValue;
+    protected internal byte[] HashValue;
+    protected int State;
+    protected HashAlgorithm() { }
+    public virtual bool CanReuseTransform { get { return default(bool); } }
+    public virtual bool CanTransformMultipleBlocks { get { return default(bool); } }
+    public virtual byte[] Hash { get { return default(byte[]); } }
+    public virtual int HashSize { get { return default(int); } }
+    public virtual int InputBlockSize { get { return default(int); } }
+    public virtual int OutputBlockSize { get { return default(int); } }
+    public void Clear() { }
+    public byte[] ComputeHash(byte[] buffer) { return default(byte[]); }
+    public byte[] ComputeHash(byte[] buffer, int offset, int count) { return default(byte[]); }
+    public byte[] ComputeHash(System.IO.Stream inputStream) { return default(byte[]); }
+    public static System.Security.Cryptography.HashAlgorithm Create() { return default(System.Security.Cryptography.HashAlgorithm); }
+    public static System.Security.Cryptography.HashAlgorithm Create(string hashName) { return default(System.Security.Cryptography.HashAlgorithm); }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    protected abstract void HashCore(byte[] array, int ibStart, int cbSize);
+    protected abstract byte[] HashFinal();
+    public abstract void Initialize();
+    public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) { return default(int); }
+    public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { return default(byte[]); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class HMAC : System.Security.Cryptography.KeyedHashAlgorithm {
+    protected HMAC() { }
+    protected int BlockSizeValue { get { return default(int); } set { } }
+    public string HashName { get { return default(string); } set { } }
+    public override byte[] Key { get { return default(byte[]); } set { } }
+    public static new System.Security.Cryptography.HMAC Create() { return default(System.Security.Cryptography.HMAC); }
+    public static new System.Security.Cryptography.HMAC Create(string algorithmName) { return default(System.Security.Cryptography.HMAC); }
+    protected override void Dispose(bool disposing) { }
+    protected override void HashCore(byte[] rgb, int ib, int cb) { }
+    protected override byte[] HashFinal() { return default(byte[]); }
+    public override void Initialize() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface ICryptoTransform : System.IDisposable {
+    bool CanReuseTransform { get; }
+    bool CanTransformMultipleBlocks { get; }
+    int InputBlockSize { get; }
+    int OutputBlockSize { get; }
+    int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset);
+    byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class KeyedHashAlgorithm : System.Security.Cryptography.HashAlgorithm {
+    protected byte[] KeyValue;
+    protected KeyedHashAlgorithm() { }
+    public virtual byte[] Key { get { return default(byte[]); } set { } }
+    public static new System.Security.Cryptography.KeyedHashAlgorithm Create() { return default(System.Security.Cryptography.KeyedHashAlgorithm); }
+    public static new System.Security.Cryptography.KeyedHashAlgorithm Create(string algName) { return default(System.Security.Cryptography.KeyedHashAlgorithm); }
+    protected override void Dispose(bool disposing) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class KeySizes {
+    public KeySizes(int minSize, int maxSize, int skipSize) { }
+    public int MaxSize { get { return default(int); } }
+    public int MinSize { get { return default(int); } }
+    public int SkipSize { get { return default(int); } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum PaddingMode {
+    ANSIX923 = 4,
+    ISO10126 = 5,
+    None = 1,
+    PKCS7 = 2,
+    Zeros = 3,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class SymmetricAlgorithm : System.IDisposable {
+    protected int BlockSizeValue;
+    protected int FeedbackSizeValue;
+    protected byte[] IVValue;
+    protected int KeySizeValue;
+    protected byte[] KeyValue;
+    protected System.Security.Cryptography.KeySizes[] LegalBlockSizesValue;
+    protected System.Security.Cryptography.KeySizes[] LegalKeySizesValue;
+    protected System.Security.Cryptography.CipherMode ModeValue;
+    protected System.Security.Cryptography.PaddingMode PaddingValue;
+    protected SymmetricAlgorithm() { }
+    public virtual int BlockSize { get { return default(int); } set { } }
+    public virtual int FeedbackSize { get { return default(int); } set { } }
+    public virtual byte[] IV { get { return default(byte[]); } set { } }
+    public virtual byte[] Key { get { return default(byte[]); } set { } }
+    public virtual int KeySize { get { return default(int); } set { } }
+    public virtual System.Security.Cryptography.KeySizes[] LegalBlockSizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
+    public virtual System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
+    public virtual System.Security.Cryptography.CipherMode Mode { get { return default(System.Security.Cryptography.CipherMode); } set { } }
+    public virtual System.Security.Cryptography.PaddingMode Padding { get { return default(System.Security.Cryptography.PaddingMode); } set { } }
+    public void Clear() { }
+    public static System.Security.Cryptography.SymmetricAlgorithm Create() { return default(System.Security.Cryptography.SymmetricAlgorithm); }
+    public static System.Security.Cryptography.SymmetricAlgorithm Create(string algName) { return default(System.Security.Cryptography.SymmetricAlgorithm); }
+    public virtual System.Security.Cryptography.ICryptoTransform CreateDecryptor() { return default(System.Security.Cryptography.ICryptoTransform); }
+    public abstract System.Security.Cryptography.ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV);
+    public virtual System.Security.Cryptography.ICryptoTransform CreateEncryptor() { return default(System.Security.Cryptography.ICryptoTransform); }
+    public abstract System.Security.Cryptography.ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV);
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public abstract void GenerateIV();
+    public abstract void GenerateKey();
+    public bool ValidKeySize(int bitLength) { return default(bool); }
+  }
+
+} // end of System.Security.Cryptography

fxdac/fxdac/Data/Contracts/System.Security.Cryptography.X509Certificates.cs

@@ -0,0 +1,441 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Cryptography.X509Certificates {
+  [System.FlagsAttribute]
+  public enum OpenFlags {
+    IncludeArchived = 8,
+    MaxAllowed = 2,
+    OpenExistingOnly = 4,
+    ReadOnly = 0,
+    ReadWrite = 1,
+  }
+
+  public sealed partial class PublicKey {
+    public PublicKey(System.Security.Cryptography.Oid oid, System.Security.Cryptography.AsnEncodedData parameters, System.Security.Cryptography.AsnEncodedData keyValue) { }
+    public System.Security.Cryptography.AsnEncodedData EncodedKeyValue { get { return default(System.Security.Cryptography.AsnEncodedData); } }
+    public System.Security.Cryptography.AsnEncodedData EncodedParameters { get { return default(System.Security.Cryptography.AsnEncodedData); } }
+    public System.Security.Cryptography.AsymmetricAlgorithm Key { get { return default(System.Security.Cryptography.AsymmetricAlgorithm); } }
+    public System.Security.Cryptography.Oid Oid { get { return default(System.Security.Cryptography.Oid); } }
+  }
+
+  public enum StoreLocation {
+    CurrentUser = 1,
+    LocalMachine = 2,
+  }
+
+  public enum StoreName {
+    AddressBook = 1,
+    AuthRoot = 2,
+    CertificateAuthority = 3,
+    Disallowed = 4,
+    My = 5,
+    Root = 6,
+    TrustedPeople = 7,
+    TrustedPublisher = 8,
+  }
+
+  public sealed partial class X500DistinguishedName : System.Security.Cryptography.AsnEncodedData {
+    public X500DistinguishedName(byte[] encodedDistinguishedName) { }
+    public X500DistinguishedName(System.Security.Cryptography.AsnEncodedData encodedDistinguishedName) { }
+    public X500DistinguishedName(System.Security.Cryptography.X509Certificates.X500DistinguishedName distinguishedName) { }
+    public X500DistinguishedName(string distinguishedName) { }
+    public X500DistinguishedName(string distinguishedName, System.Security.Cryptography.X509Certificates.X500DistinguishedNameFlags flag) { }
+    public string Name { get { return default(string); } }
+    public string Decode(System.Security.Cryptography.X509Certificates.X500DistinguishedNameFlags flag) { return default(string); }
+    public override string Format(bool multiLine) { return default(string); }
+  }
+
+  [System.FlagsAttribute]
+  public enum X500DistinguishedNameFlags {
+    DoNotUsePlusSign = 32,
+    DoNotUseQuotes = 64,
+    ForceUTF8Encoding = 16384,
+    None = 0,
+    Reversed = 1,
+    UseCommas = 128,
+    UseNewLines = 256,
+    UseSemicolons = 16,
+    UseT61Encoding = 8192,
+    UseUTF8Encoding = 4096,
+  }
+
+  public sealed partial class X509BasicConstraintsExtension : System.Security.Cryptography.X509Certificates.X509Extension {
+    public X509BasicConstraintsExtension() { }
+    public X509BasicConstraintsExtension(bool certificateAuthority, bool hasPathLengthConstraint, int pathLengthConstraint, bool critical) { }
+    public X509BasicConstraintsExtension(System.Security.Cryptography.AsnEncodedData encodedBasicConstraints, bool critical) { }
+    public bool CertificateAuthority { get { return default(bool); } }
+    public bool HasPathLengthConstraint { get { return default(bool); } }
+    public int PathLengthConstraint { get { return default(int); } }
+    public override void CopyFrom(System.Security.Cryptography.AsnEncodedData asnEncodedData) { }
+  }
+
+  public partial class X509Certificate2 : System.Security.Cryptography.X509Certificates.X509Certificate {
+    public X509Certificate2() { }
+    public X509Certificate2(byte[] rawData) { }
+    public X509Certificate2(byte[] rawData, System.Security.SecureString password) { }
+    public X509Certificate2(byte[] rawData, System.Security.SecureString password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public X509Certificate2(byte[] rawData, string password) { }
+    public X509Certificate2(byte[] rawData, string password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public X509Certificate2(System.IntPtr handle) { }
+    public X509Certificate2(System.Security.Cryptography.X509Certificates.X509Certificate certificate) { }
+    public X509Certificate2(string fileName) { }
+    public X509Certificate2(string fileName, System.Security.SecureString password) { }
+    public X509Certificate2(string fileName, System.Security.SecureString password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public X509Certificate2(string fileName, string password) { }
+    public X509Certificate2(string fileName, string password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public bool Archived { get { return default(bool); } set { } }
+    public System.Security.Cryptography.X509Certificates.X509ExtensionCollection Extensions { get { return default(System.Security.Cryptography.X509Certificates.X509ExtensionCollection); } }
+    public string FriendlyName { get { return default(string); } set { } }
+    public bool HasPrivateKey { get { return default(bool); } }
+    public System.Security.Cryptography.X509Certificates.X500DistinguishedName IssuerName { get { return default(System.Security.Cryptography.X509Certificates.X500DistinguishedName); } }
+    public System.DateTime NotAfter { get { return default(System.DateTime); } }
+    public System.DateTime NotBefore { get { return default(System.DateTime); } }
+    public System.Security.Cryptography.AsymmetricAlgorithm PrivateKey { get { return default(System.Security.Cryptography.AsymmetricAlgorithm); } set { } }
+    public System.Security.Cryptography.X509Certificates.PublicKey PublicKey { get { return default(System.Security.Cryptography.X509Certificates.PublicKey); } }
+    public byte[] RawData { get { return default(byte[]); } }
+    public string SerialNumber { get { return default(string); } }
+    public System.Security.Cryptography.Oid SignatureAlgorithm { get { return default(System.Security.Cryptography.Oid); } }
+    public System.Security.Cryptography.X509Certificates.X500DistinguishedName SubjectName { get { return default(System.Security.Cryptography.X509Certificates.X500DistinguishedName); } }
+    public string Thumbprint { get { return default(string); } }
+    public int Version { get { return default(int); } }
+    public static System.Security.Cryptography.X509Certificates.X509ContentType GetCertContentType(byte[] rawData) { return default(System.Security.Cryptography.X509Certificates.X509ContentType); }
+    public static System.Security.Cryptography.X509Certificates.X509ContentType GetCertContentType(string fileName) { return default(System.Security.Cryptography.X509Certificates.X509ContentType); }
+    public string GetNameInfo(System.Security.Cryptography.X509Certificates.X509NameType nameType, bool forIssuer) { return default(string); }
+    public override void Import(byte[] rawData) { }
+    public override void Import(byte[] rawData, System.Security.SecureString password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public override void Import(byte[] rawData, string password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public override void Import(string fileName) { }
+    public override void Import(string fileName, System.Security.SecureString password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public override void Import(string fileName, string password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public override void Reset() { }
+    public override string ToString() { return default(string); }
+    public override string ToString(bool verbose) { return default(string); }
+    public bool Verify() { return default(bool); }
+  }
+
+  public partial class X509Certificate2Collection : System.Security.Cryptography.X509Certificates.X509CertificateCollection {
+    public X509Certificate2Collection() { }
+    public X509Certificate2Collection(System.Security.Cryptography.X509Certificates.X509Certificate2 certificate) { }
+    public X509Certificate2Collection(System.Security.Cryptography.X509Certificates.X509Certificate2[] certificates) { }
+    public X509Certificate2Collection(System.Security.Cryptography.X509Certificates.X509Certificate2Collection certificates) { }
+    public new System.Security.Cryptography.X509Certificates.X509Certificate2 this[int index] { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate2); } set { } }
+    public int Add(System.Security.Cryptography.X509Certificates.X509Certificate2 certificate) { return default(int); }
+    public void AddRange(System.Security.Cryptography.X509Certificates.X509Certificate2[] certificates) { }
+    public void AddRange(System.Security.Cryptography.X509Certificates.X509Certificate2Collection certificates) { }
+    public bool Contains(System.Security.Cryptography.X509Certificates.X509Certificate2 certificate) { return default(bool); }
+    public byte[] Export(System.Security.Cryptography.X509Certificates.X509ContentType contentType) { return default(byte[]); }
+    public byte[] Export(System.Security.Cryptography.X509Certificates.X509ContentType contentType, string password) { return default(byte[]); }
+    public System.Security.Cryptography.X509Certificates.X509Certificate2Collection Find(System.Security.Cryptography.X509Certificates.X509FindType findType, object findValue, bool validOnly) { return default(System.Security.Cryptography.X509Certificates.X509Certificate2Collection); }
+    public new System.Security.Cryptography.X509Certificates.X509Certificate2Enumerator GetEnumerator() { return default(System.Security.Cryptography.X509Certificates.X509Certificate2Enumerator); }
+    public void Import(byte[] rawData) { }
+    public void Import(byte[] rawData, string password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public void Import(string fileName) { }
+    public void Import(string fileName, string password, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags keyStorageFlags) { }
+    public void Insert(int index, System.Security.Cryptography.X509Certificates.X509Certificate2 certificate) { }
+    public void Remove(System.Security.Cryptography.X509Certificates.X509Certificate2 certificate) { }
+    public void RemoveRange(System.Security.Cryptography.X509Certificates.X509Certificate2[] certificates) { }
+    public void RemoveRange(System.Security.Cryptography.X509Certificates.X509Certificate2Collection certificates) { }
+  }
+
+  public sealed partial class X509Certificate2Enumerator : System.Collections.IEnumerator {
+    internal X509Certificate2Enumerator() { }
+    public System.Security.Cryptography.X509Certificates.X509Certificate2 Current { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate2); } }
+    object System.Collections.IEnumerator.Current { get { return default(object); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+    bool System.Collections.IEnumerator.MoveNext() { return default(bool); }
+    void System.Collections.IEnumerator.Reset() { }
+  }
+
+  public partial class X509CertificateCollection : System.Collections.CollectionBase {
+    public X509CertificateCollection() { }
+    public X509CertificateCollection(System.Security.Cryptography.X509Certificates.X509Certificate[] value) { }
+    public X509CertificateCollection(System.Security.Cryptography.X509Certificates.X509CertificateCollection value) { }
+    public System.Security.Cryptography.X509Certificates.X509Certificate this[int index] { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } set { } }
+    public int Add(System.Security.Cryptography.X509Certificates.X509Certificate value) { return default(int); }
+    public void AddRange(System.Security.Cryptography.X509Certificates.X509Certificate[] value) { }
+    public void AddRange(System.Security.Cryptography.X509Certificates.X509CertificateCollection value) { }
+    public bool Contains(System.Security.Cryptography.X509Certificates.X509Certificate value) { return default(bool); }
+    public void CopyTo(System.Security.Cryptography.X509Certificates.X509Certificate[] array, int index) { }
+    public new System.Security.Cryptography.X509Certificates.X509CertificateCollection.X509CertificateEnumerator GetEnumerator() { return default(System.Security.Cryptography.X509Certificates.X509CertificateCollection.X509CertificateEnumerator); }
+    public override int GetHashCode() { return default(int); }
+    public int IndexOf(System.Security.Cryptography.X509Certificates.X509Certificate value) { return default(int); }
+    public void Insert(int index, System.Security.Cryptography.X509Certificates.X509Certificate value) { }
+    public void Remove(System.Security.Cryptography.X509Certificates.X509Certificate value) { }
+    public partial class X509CertificateEnumerator : System.Collections.IEnumerator {
+      public X509CertificateEnumerator(System.Security.Cryptography.X509Certificates.X509CertificateCollection mappings) { }
+      public System.Security.Cryptography.X509Certificates.X509Certificate Current { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } }
+      object System.Collections.IEnumerator.Current { get { return default(object); } }
+      public bool MoveNext() { return default(bool); }
+      public void Reset() { }
+      bool System.Collections.IEnumerator.MoveNext() { return default(bool); }
+      void System.Collections.IEnumerator.Reset() { }
+    }
+  }
+
+  public partial class X509Chain {
+    public X509Chain() { }
+    public X509Chain(bool useMachineContext) { }
+    public X509Chain(System.IntPtr chainContext) { }
+    public System.IntPtr ChainContext { get { return default(System.IntPtr); } }
+    public System.Security.Cryptography.X509Certificates.X509ChainElementCollection ChainElements { get { return default(System.Security.Cryptography.X509Certificates.X509ChainElementCollection); } }
+    public System.Security.Cryptography.X509Certificates.X509ChainPolicy ChainPolicy { get { return default(System.Security.Cryptography.X509Certificates.X509ChainPolicy); } set { } }
+    public System.Security.Cryptography.X509Certificates.X509ChainStatus[] ChainStatus { get { return default(System.Security.Cryptography.X509Certificates.X509ChainStatus[]); } }
+    public bool Build(System.Security.Cryptography.X509Certificates.X509Certificate2 certificate) { return default(bool); }
+    public static System.Security.Cryptography.X509Certificates.X509Chain Create() { return default(System.Security.Cryptography.X509Certificates.X509Chain); }
+    public void Reset() { }
+  }
+
+  public partial class X509ChainElement {
+    internal X509ChainElement() { }
+    public System.Security.Cryptography.X509Certificates.X509Certificate2 Certificate { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate2); } }
+    public System.Security.Cryptography.X509Certificates.X509ChainStatus[] ChainElementStatus { get { return default(System.Security.Cryptography.X509Certificates.X509ChainStatus[]); } }
+    public string Information { get { return default(string); } }
+  }
+
+  public sealed partial class X509ChainElementCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    internal X509ChainElementCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Security.Cryptography.X509Certificates.X509ChainElement this[int index] { get { return default(System.Security.Cryptography.X509Certificates.X509ChainElement); } }
+    public object SyncRoot { get { return default(object); } }
+    public void CopyTo(System.Security.Cryptography.X509Certificates.X509ChainElement[] array, int index) { }
+    public System.Security.Cryptography.X509Certificates.X509ChainElementEnumerator GetEnumerator() { return default(System.Security.Cryptography.X509Certificates.X509ChainElementEnumerator); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public sealed partial class X509ChainElementEnumerator : System.Collections.IEnumerator {
+    internal X509ChainElementEnumerator() { }
+    public System.Security.Cryptography.X509Certificates.X509ChainElement Current { get { return default(System.Security.Cryptography.X509Certificates.X509ChainElement); } }
+    object System.Collections.IEnumerator.Current { get { return default(object); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+  public sealed partial class X509ChainPolicy {
+    public X509ChainPolicy() { }
+    public System.Security.Cryptography.OidCollection ApplicationPolicy { get { return default(System.Security.Cryptography.OidCollection); } }
+    public System.Security.Cryptography.OidCollection CertificatePolicy { get { return default(System.Security.Cryptography.OidCollection); } }
+    public System.Security.Cryptography.X509Certificates.X509Certificate2Collection ExtraStore { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate2Collection); } }
+    public System.Security.Cryptography.X509Certificates.X509RevocationFlag RevocationFlag { get { return default(System.Security.Cryptography.X509Certificates.X509RevocationFlag); } set { } }
+    public System.Security.Cryptography.X509Certificates.X509RevocationMode RevocationMode { get { return default(System.Security.Cryptography.X509Certificates.X509RevocationMode); } set { } }
+    public System.TimeSpan UrlRetrievalTimeout { get { return default(System.TimeSpan); } set { } }
+    public System.Security.Cryptography.X509Certificates.X509VerificationFlags VerificationFlags { get { return default(System.Security.Cryptography.X509Certificates.X509VerificationFlags); } set { } }
+    public System.DateTime VerificationTime { get { return default(System.DateTime); } set { } }
+    public void Reset() { }
+  }
+
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct X509ChainStatus {
+    public System.Security.Cryptography.X509Certificates.X509ChainStatusFlags Status { get { return default(System.Security.Cryptography.X509Certificates.X509ChainStatusFlags); } set { } }
+    public string StatusInformation { get { return default(string); } set { } }
+  }
+
+  [System.FlagsAttribute]
+  public enum X509ChainStatusFlags {
+    CtlNotSignatureValid = 262144,
+    CtlNotTimeValid = 131072,
+    CtlNotValidForUsage = 524288,
+    Cyclic = 128,
+    HasExcludedNameConstraint = 32768,
+    HasNotDefinedNameConstraint = 8192,
+    HasNotPermittedNameConstraint = 16384,
+    HasNotSupportedNameConstraint = 4096,
+    InvalidBasicConstraints = 1024,
+    InvalidExtension = 256,
+    InvalidNameConstraints = 2048,
+    InvalidPolicyConstraints = 512,
+    NoError = 0,
+    NoIssuanceChainPolicy = 33554432,
+    NotSignatureValid = 8,
+    NotTimeNested = 2,
+    NotTimeValid = 1,
+    NotValidForUsage = 16,
+    OfflineRevocation = 16777216,
+    PartialChain = 65536,
+    RevocationStatusUnknown = 64,
+    Revoked = 4,
+    UntrustedRoot = 32,
+  }
+
+  public sealed partial class X509EnhancedKeyUsageExtension : System.Security.Cryptography.X509Certificates.X509Extension {
+    public X509EnhancedKeyUsageExtension() { }
+    public X509EnhancedKeyUsageExtension(System.Security.Cryptography.AsnEncodedData encodedEnhancedKeyUsages, bool critical) { }
+    public X509EnhancedKeyUsageExtension(System.Security.Cryptography.OidCollection enhancedKeyUsages, bool critical) { }
+    public System.Security.Cryptography.OidCollection EnhancedKeyUsages { get { return default(System.Security.Cryptography.OidCollection); } }
+    public override void CopyFrom(System.Security.Cryptography.AsnEncodedData asnEncodedData) { }
+  }
+
+  public partial class X509Extension : System.Security.Cryptography.AsnEncodedData {
+    protected X509Extension() { }
+    public X509Extension(System.Security.Cryptography.AsnEncodedData encodedExtension, bool critical) { }
+    public X509Extension(System.Security.Cryptography.Oid oid, byte[] rawData, bool critical) { }
+    public X509Extension(string oid, byte[] rawData, bool critical) { }
+    public bool Critical { get { return default(bool); } set { } }
+    public override void CopyFrom(System.Security.Cryptography.AsnEncodedData asnEncodedData) { }
+  }
+
+  public sealed partial class X509ExtensionCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    public X509ExtensionCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Security.Cryptography.X509Certificates.X509Extension this[int index] { get { return default(System.Security.Cryptography.X509Certificates.X509Extension); } }
+    public System.Security.Cryptography.X509Certificates.X509Extension this[string oid] { get { return default(System.Security.Cryptography.X509Certificates.X509Extension); } }
+    public object SyncRoot { get { return default(object); } }
+    public int Add(System.Security.Cryptography.X509Certificates.X509Extension extension) { return default(int); }
+    public void CopyTo(System.Security.Cryptography.X509Certificates.X509Extension[] array, int index) { }
+    public System.Security.Cryptography.X509Certificates.X509ExtensionEnumerator GetEnumerator() { return default(System.Security.Cryptography.X509Certificates.X509ExtensionEnumerator); }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public sealed partial class X509ExtensionEnumerator : System.Collections.IEnumerator {
+    internal X509ExtensionEnumerator() { }
+    public System.Security.Cryptography.X509Certificates.X509Extension Current { get { return default(System.Security.Cryptography.X509Certificates.X509Extension); } }
+    object System.Collections.IEnumerator.Current { get { return default(object); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+  public enum X509FindType {
+    FindByApplicationPolicy = 10,
+    FindByCertificatePolicy = 11,
+    FindByExtension = 12,
+    FindByIssuerDistinguishedName = 4,
+    FindByIssuerName = 3,
+    FindByKeyUsage = 13,
+    FindBySerialNumber = 5,
+    FindBySubjectDistinguishedName = 2,
+    FindBySubjectKeyIdentifier = 14,
+    FindBySubjectName = 1,
+    FindByTemplateName = 9,
+    FindByThumbprint = 0,
+    FindByTimeExpired = 8,
+    FindByTimeNotYetValid = 7,
+    FindByTimeValid = 6,
+  }
+
+  public enum X509IncludeOption {
+    EndCertOnly = 2,
+    ExcludeRoot = 1,
+    None = 0,
+    WholeChain = 3,
+  }
+
+  public sealed partial class X509KeyUsageExtension : System.Security.Cryptography.X509Certificates.X509Extension {
+    public X509KeyUsageExtension() { }
+    public X509KeyUsageExtension(System.Security.Cryptography.AsnEncodedData encodedKeyUsage, bool critical) { }
+    public X509KeyUsageExtension(System.Security.Cryptography.X509Certificates.X509KeyUsageFlags keyUsages, bool critical) { }
+    public System.Security.Cryptography.X509Certificates.X509KeyUsageFlags KeyUsages { get { return default(System.Security.Cryptography.X509Certificates.X509KeyUsageFlags); } }
+    public override void CopyFrom(System.Security.Cryptography.AsnEncodedData encodedData) { }
+  }
+
+  [System.FlagsAttribute]
+  public enum X509KeyUsageFlags {
+    CrlSign = 2,
+    DataEncipherment = 16,
+    DecipherOnly = 32768,
+    DigitalSignature = 128,
+    EncipherOnly = 1,
+    KeyAgreement = 8,
+    KeyCertSign = 4,
+    KeyEncipherment = 32,
+    None = 0,
+    NonRepudiation = 64,
+  }
+
+  public enum X509NameType {
+    DnsFromAlternativeName = 4,
+    DnsName = 3,
+    EmailName = 1,
+    SimpleName = 0,
+    UpnName = 2,
+    UrlName = 5,
+  }
+
+  public enum X509RevocationFlag {
+    EndCertificateOnly = 0,
+    EntireChain = 1,
+    ExcludeRoot = 2,
+  }
+
+  public enum X509RevocationMode {
+    NoCheck = 0,
+    Offline = 2,
+    Online = 1,
+  }
+
+  public sealed partial class X509Store {
+    public X509Store() { }
+    public X509Store(System.IntPtr storeHandle) { }
+    public X509Store(System.Security.Cryptography.X509Certificates.StoreLocation storeLocation) { }
+    public X509Store(System.Security.Cryptography.X509Certificates.StoreName storeName) { }
+    public X509Store(System.Security.Cryptography.X509Certificates.StoreName storeName, System.Security.Cryptography.X509Certificates.StoreLocation storeLocation) { }
+    public X509Store(string storeName) { }
+    public X509Store(string storeName, System.Security.Cryptography.X509Certificates.StoreLocation storeLocation) { }
+    public System.Security.Cryptography.X509Certificates.X509Certificate2Collection Certificates { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate2Collection); } }
+    public System.Security.Cryptography.X509Certificates.StoreLocation Location { get { return default(System.Security.Cryptography.X509Certificates.StoreLocation); } }
+    public string Name { get { return default(string); } }
+    public System.IntPtr StoreHandle { get { return default(System.IntPtr); } }
+    public void Add(System.Security.Cryptography.X509Certificates.X509Certificate2 certificate) { }
+    public void AddRange(System.Security.Cryptography.X509Certificates.X509Certificate2Collection certificates) { }
+    public void Close() { }
+    public void Open(System.Security.Cryptography.X509Certificates.OpenFlags flags) { }
+    public void Remove(System.Security.Cryptography.X509Certificates.X509Certificate2 certificate) { }
+    public void RemoveRange(System.Security.Cryptography.X509Certificates.X509Certificate2Collection certificates) { }
+  }
+
+  public sealed partial class X509SubjectKeyIdentifierExtension : System.Security.Cryptography.X509Certificates.X509Extension {
+    public X509SubjectKeyIdentifierExtension() { }
+    public X509SubjectKeyIdentifierExtension(byte[] subjectKeyIdentifier, bool critical) { }
+    public X509SubjectKeyIdentifierExtension(System.Security.Cryptography.AsnEncodedData encodedSubjectKeyIdentifier, bool critical) { }
+    public X509SubjectKeyIdentifierExtension(System.Security.Cryptography.X509Certificates.PublicKey key, bool critical) { }
+    public X509SubjectKeyIdentifierExtension(System.Security.Cryptography.X509Certificates.PublicKey key, System.Security.Cryptography.X509Certificates.X509SubjectKeyIdentifierHashAlgorithm algorithm, bool critical) { }
+    public X509SubjectKeyIdentifierExtension(string subjectKeyIdentifier, bool critical) { }
+    public string SubjectKeyIdentifier { get { return default(string); } }
+    public override void CopyFrom(System.Security.Cryptography.AsnEncodedData encodedData) { }
+  }
+
+  public enum X509SubjectKeyIdentifierHashAlgorithm {
+    CapiSha1 = 2,
+    Sha1 = 0,
+    ShortSha1 = 1,
+  }
+
+  [System.FlagsAttribute]
+  public enum X509VerificationFlags {
+    AllFlags = 4095,
+    AllowUnknownCertificateAuthority = 16,
+    IgnoreCertificateAuthorityRevocationUnknown = 1024,
+    IgnoreCtlNotTimeValid = 2,
+    IgnoreCtlSignerRevocationUnknown = 512,
+    IgnoreEndRevocationUnknown = 256,
+    IgnoreInvalidBasicConstraints = 8,
+    IgnoreInvalidName = 64,
+    IgnoreInvalidPolicy = 128,
+    IgnoreNotTimeNested = 4,
+    IgnoreNotTimeValid = 1,
+    IgnoreRootRevocationUnknown = 2048,
+    IgnoreWrongUsage = 32,
+    NoFlag = 0,
+  }
+
+} // end of System.Security.Cryptography.X509Certificates
+namespace System.Security.Cryptography {
+  public sealed partial class AesCryptoServiceProvider : System.Security.Cryptography.Aes {
+    public AesCryptoServiceProvider() { }
+    public override System.Security.Cryptography.ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override System.Security.Cryptography.ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override void GenerateIV() { }
+    public override void GenerateKey() { }
+  }
+
+  public sealed partial class AesManaged : System.Security.Cryptography.Aes {
+    public AesManaged() { }
+    public override System.Security.Cryptography.ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override System.Security.Cryptography.ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV) { return default(System.Security.Cryptography.ICryptoTransform); }
+    public override void GenerateIV() { }
+    public override void GenerateKey() { }
+  }
+
+} // end of System.Security.Cryptography

fxdac/fxdac/Data/Contracts/System.Security.Cryptography.cs

@@ -0,0 +1 @@
+[assembly:System.CLSCompliant(true)]

fxdac/fxdac/Data/Contracts/System.Security.Permissions.cs

@@ -0,0 +1,399 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class CodeAccessPermission : System.Security.IPermission, System.Security.ISecurityEncodable, System.Security.IStackWalk {
+    protected CodeAccessPermission() { }
+    public void Assert() { }
+    public abstract System.Security.IPermission Copy();
+    public void Demand() { }
+    public void Deny() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override bool Equals(object obj) { return default(bool); }
+    public abstract void FromXml(System.Security.SecurityElement elem);
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetHashCode() { return default(int); }
+    public abstract System.Security.IPermission Intersect(System.Security.IPermission target);
+    public abstract bool IsSubsetOf(System.Security.IPermission target);
+    public void PermitOnly() { }
+    public static void RevertAll() { }
+    public static void RevertAssert() { }
+    public static void RevertDeny() { }
+    public static void RevertPermitOnly() { }
+    public override string ToString() { return default(string); }
+    public abstract System.Security.SecurityElement ToXml();
+    public virtual System.Security.IPermission Union(System.Security.IPermission other) { return default(System.Security.IPermission); }
+  }
+
+} // end of System.Security
+namespace System.Security.Permissions {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class EnvironmentPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public EnvironmentPermission(System.Security.Permissions.EnvironmentPermissionAccess flag, string pathList) { }
+    public EnvironmentPermission(System.Security.Permissions.PermissionState state) { }
+    public void AddPathList(System.Security.Permissions.EnvironmentPermissionAccess flag, string pathList) { }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public string GetPathList(System.Security.Permissions.EnvironmentPermissionAccess flag) { return default(string); }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public void SetPathList(System.Security.Permissions.EnvironmentPermissionAccess flag, string pathList) { }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission other) { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class FileDialogPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public FileDialogPermission(System.Security.Permissions.FileDialogPermissionAccess access) { }
+    public FileDialogPermission(System.Security.Permissions.PermissionState state) { }
+    public System.Security.Permissions.FileDialogPermissionAccess Access { get { return default(System.Security.Permissions.FileDialogPermissionAccess); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum FileDialogPermissionAccess {
+    None = 0,
+    Open = 1,
+    OpenSave = 3,
+    Save = 2,
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class FileDialogPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public FileDialogPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public bool Open { get { return default(bool); } set { } }
+    public bool Save { get { return default(bool); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class FileIOPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public FileIOPermission(System.Security.Permissions.FileIOPermissionAccess access, System.Security.AccessControl.AccessControlActions control, string path) { }
+    public FileIOPermission(System.Security.Permissions.FileIOPermissionAccess access, System.Security.AccessControl.AccessControlActions control, string[] pathList) { }
+    public FileIOPermission(System.Security.Permissions.FileIOPermissionAccess access, string path) { }
+    public FileIOPermission(System.Security.Permissions.FileIOPermissionAccess access, string[] pathList) { }
+    public FileIOPermission(System.Security.Permissions.PermissionState state) { }
+    public System.Security.Permissions.FileIOPermissionAccess AllFiles { get { return default(System.Security.Permissions.FileIOPermissionAccess); } set { } }
+    public System.Security.Permissions.FileIOPermissionAccess AllLocalFiles { get { return default(System.Security.Permissions.FileIOPermissionAccess); } set { } }
+    public void AddPathList(System.Security.Permissions.FileIOPermissionAccess access, string path) { }
+    public void AddPathList(System.Security.Permissions.FileIOPermissionAccess access, string[] pathList) { }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override bool Equals(object obj) { return default(bool); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetHashCode() { return default(int); }
+    public string[] GetPathList(System.Security.Permissions.FileIOPermissionAccess access) { return default(string[]); }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public void SetPathList(System.Security.Permissions.FileIOPermissionAccess access, string path) { }
+    public void SetPathList(System.Security.Permissions.FileIOPermissionAccess access, string[] pathList) { }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission other) { return default(System.Security.IPermission); }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum FileIOPermissionAccess {
+    AllAccess = 15,
+    Append = 4,
+    NoAccess = 0,
+    PathDiscovery = 8,
+    Read = 1,
+    Write = 2,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class GacIdentityPermission : System.Security.CodeAccessPermission {
+    public GacIdentityPermission() { }
+    public GacIdentityPermission(System.Security.Permissions.PermissionState state) { }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement securityElement) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class GacIdentityPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public GacIdentityPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface IUnrestrictedPermission {
+    bool IsUnrestricted();
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class PrincipalPermission : System.Security.IPermission, System.Security.ISecurityEncodable, System.Security.Permissions.IUnrestrictedPermission {
+    public PrincipalPermission(System.Security.Permissions.PermissionState state) { }
+    public PrincipalPermission(string name, string role) { }
+    public PrincipalPermission(string name, string role, bool isAuthenticated) { }
+    public System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public void Demand() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override bool Equals(object obj) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement elem) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetHashCode() { return default(int); }
+    public System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.IPermission Union(System.Security.IPermission other) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(68), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class PrincipalPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public PrincipalPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public bool Authenticated { get { return default(bool); } set { } }
+    public string Name { get { return default(string); } set { } }
+    public string Role { get { return default(string); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class PublisherIdentityPermission : System.Security.CodeAccessPermission {
+    public PublisherIdentityPermission(System.Security.Cryptography.X509Certificates.X509Certificate certificate) { }
+    public PublisherIdentityPermission(System.Security.Permissions.PermissionState state) { }
+    public System.Security.Cryptography.X509Certificates.X509Certificate Certificate { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class PublisherIdentityPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public PublisherIdentityPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public string CertFile { get { return default(string); } set { } }
+    public string SignedFile { get { return default(string); } set { } }
+    public string X509Certificate { get { return default(string); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ReflectionPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public ReflectionPermission(System.Security.Permissions.PermissionState state) { }
+    public ReflectionPermission(System.Security.Permissions.ReflectionPermissionFlag flag) { }
+    public System.Security.Permissions.ReflectionPermissionFlag Flags { get { return default(System.Security.Permissions.ReflectionPermissionFlag); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission other) { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class RegistryPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public RegistryPermission(System.Security.Permissions.PermissionState state) { }
+    public RegistryPermission(System.Security.Permissions.RegistryPermissionAccess access, System.Security.AccessControl.AccessControlActions control, string pathList) { }
+    public RegistryPermission(System.Security.Permissions.RegistryPermissionAccess access, string pathList) { }
+    public void AddPathList(System.Security.Permissions.RegistryPermissionAccess access, System.Security.AccessControl.AccessControlActions control, string pathList) { }
+    public void AddPathList(System.Security.Permissions.RegistryPermissionAccess access, string pathList) { }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public string GetPathList(System.Security.Permissions.RegistryPermissionAccess access) { return default(string); }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public void SetPathList(System.Security.Permissions.RegistryPermissionAccess access, string pathList) { }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission other) { return default(System.Security.IPermission); }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum RegistryPermissionAccess {
+    AllAccess = 7,
+    Create = 4,
+    NoAccess = 0,
+    Read = 1,
+    Write = 2,
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class RegistryPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public RegistryPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    [System.ObsoleteAttribute("use newer properties")]
+    public string All { get { return default(string); } set { } }
+    public string ChangeAccessControl { get { return default(string); } set { } }
+    public string Create { get { return default(string); } set { } }
+    public string Read { get { return default(string); } set { } }
+    public string ViewAccessControl { get { return default(string); } set { } }
+    public string ViewAndModify { get { return default(string); } set { } }
+    public string Write { get { return default(string); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class SecurityPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public SecurityPermission(System.Security.Permissions.PermissionState state) { }
+    public SecurityPermission(System.Security.Permissions.SecurityPermissionFlag flag) { }
+    public System.Security.Permissions.SecurityPermissionFlag Flags { get { return default(System.Security.Permissions.SecurityPermissionFlag); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class SiteIdentityPermission : System.Security.CodeAccessPermission {
+    public SiteIdentityPermission(System.Security.Permissions.PermissionState state) { }
+    public SiteIdentityPermission(string site) { }
+    public string Site { get { return default(string); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class SiteIdentityPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public SiteIdentityPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public string Site { get { return default(string); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class StrongNameIdentityPermission : System.Security.CodeAccessPermission {
+    public StrongNameIdentityPermission(System.Security.Permissions.PermissionState state) { }
+    public StrongNameIdentityPermission(System.Security.Permissions.StrongNamePublicKeyBlob blob, string name, System.Version version) { }
+    public string Name { get { return default(string); } set { } }
+    public System.Security.Permissions.StrongNamePublicKeyBlob PublicKey { get { return default(System.Security.Permissions.StrongNamePublicKeyBlob); } set { } }
+    public System.Version Version { get { return default(System.Version); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement e) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class UIPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public UIPermission(System.Security.Permissions.PermissionState state) { }
+    public UIPermission(System.Security.Permissions.UIPermissionClipboard clipboardFlag) { }
+    public UIPermission(System.Security.Permissions.UIPermissionWindow windowFlag) { }
+    public UIPermission(System.Security.Permissions.UIPermissionWindow windowFlag, System.Security.Permissions.UIPermissionClipboard clipboardFlag) { }
+    public System.Security.Permissions.UIPermissionClipboard Clipboard { get { return default(System.Security.Permissions.UIPermissionClipboard); } set { } }
+    public System.Security.Permissions.UIPermissionWindow Window { get { return default(System.Security.Permissions.UIPermissionWindow); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class UIPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public UIPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public System.Security.Permissions.UIPermissionClipboard Clipboard { get { return default(System.Security.Permissions.UIPermissionClipboard); } set { } }
+    public System.Security.Permissions.UIPermissionWindow Window { get { return default(System.Security.Permissions.UIPermissionWindow); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum UIPermissionClipboard {
+    AllClipboard = 2,
+    NoClipboard = 0,
+    OwnClipboard = 1,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum UIPermissionWindow {
+    AllWindows = 3,
+    NoWindows = 0,
+    SafeSubWindows = 1,
+    SafeTopLevelWindows = 2,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class UrlIdentityPermission : System.Security.CodeAccessPermission {
+    public UrlIdentityPermission(System.Security.Permissions.PermissionState state) { }
+    public UrlIdentityPermission(string site) { }
+    public string Url { get { return default(string); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class UrlIdentityPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public UrlIdentityPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public string Url { get { return default(string); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ZoneIdentityPermission : System.Security.CodeAccessPermission {
+    public ZoneIdentityPermission(System.Security.Permissions.PermissionState state) { }
+    public ZoneIdentityPermission(System.Security.SecurityZone zone) { }
+    public System.Security.SecurityZone SecurityZone { get { return default(System.Security.SecurityZone); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement esd) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(109), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ZoneIdentityPermissionAttribute : System.Security.Permissions.CodeAccessSecurityAttribute {
+    public ZoneIdentityPermissionAttribute(System.Security.Permissions.SecurityAction action) : base (default(System.Security.Permissions.SecurityAction)) { }
+    public System.Security.SecurityZone Zone { get { return default(System.Security.SecurityZone); } set { } }
+    public override System.Security.IPermission CreatePermission() { return default(System.Security.IPermission); }
+  }
+
+} // end of System.Security.Permissions
+namespace System.Security.Policy {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class FileCodeGroup : System.Security.Policy.CodeGroup {
+    public FileCodeGroup(System.Security.Policy.IMembershipCondition membershipCondition, System.Security.Permissions.FileIOPermissionAccess access) : base (default(System.Security.Policy.IMembershipCondition), default(System.Security.Policy.PolicyStatement)) { }
+    public override string AttributeString { get { return default(string); } }
+    public override string MergeLogic { get { return default(string); } }
+    public override string PermissionSetName { get { return default(string); } }
+    public override System.Security.Policy.CodeGroup Copy() { return default(System.Security.Policy.CodeGroup); }
+    protected override void CreateXml(System.Security.SecurityElement element, System.Security.Policy.PolicyLevel level) { }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    protected override void ParseXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override System.Security.Policy.PolicyStatement Resolve(System.Security.Policy.Evidence evidence) { return default(System.Security.Policy.PolicyStatement); }
+    public override System.Security.Policy.CodeGroup ResolveMatchingCodeGroups(System.Security.Policy.Evidence evidence) { return default(System.Security.Policy.CodeGroup); }
+  }
+
+} // end of System.Security.Policy

fxdac/fxdac/Data/Contracts/System.Security.Policy.cs

@@ -0,0 +1,331 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Policy {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class AllMembershipCondition : System.Security.ISecurityEncodable, System.Security.ISecurityPolicyEncodable, System.Security.Policy.IMembershipCondition {
+    public AllMembershipCondition() { }
+    public bool Check(System.Security.Policy.Evidence evidence) { return default(bool); }
+    public System.Security.Policy.IMembershipCondition Copy() { return default(System.Security.Policy.IMembershipCondition); }
+    public override bool Equals(object o) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement e) { }
+    public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level) { return default(System.Security.SecurityElement); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ApplicationDirectory : System.Security.Policy.EvidenceBase {
+    public ApplicationDirectory(string name) { }
+    public string Directory { get { return default(string); } }
+    public object Copy() { return default(object); }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ApplicationDirectoryMembershipCondition : System.Security.ISecurityEncodable, System.Security.ISecurityPolicyEncodable, System.Security.Policy.IMembershipCondition {
+    public ApplicationDirectoryMembershipCondition() { }
+    public bool Check(System.Security.Policy.Evidence evidence) { return default(bool); }
+    public System.Security.Policy.IMembershipCondition Copy() { return default(System.Security.Policy.IMembershipCondition); }
+    public override bool Equals(object o) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement e) { }
+    public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level) { return default(System.Security.SecurityElement); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ApplicationSecurityInfo {
+    public ApplicationSecurityInfo(System.ActivationContext activationContext) { }
+    public System.Security.Policy.Evidence ApplicationEvidence { get { return default(System.Security.Policy.Evidence); } set { } }
+    public System.ApplicationId ApplicationId { get { return default(System.ApplicationId); } set { } }
+    public System.Security.PermissionSet DefaultRequestSet { get { return default(System.Security.PermissionSet); } set { } }
+    public System.ApplicationId DeploymentId { get { return default(System.ApplicationId); } set { } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public static partial class ApplicationSecurityManager {
+    public static System.Security.Policy.IApplicationTrustManager ApplicationTrustManager { get { return default(System.Security.Policy.IApplicationTrustManager); } }
+    public static System.Security.Policy.ApplicationTrustCollection UserApplicationTrusts { get { return default(System.Security.Policy.ApplicationTrustCollection); } }
+    public static bool DetermineApplicationTrust(System.ActivationContext activationContext, System.Security.Policy.TrustManagerContext context) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ApplicationTrustCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    internal ApplicationTrustCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Security.Policy.ApplicationTrust this[int index] { get { return default(System.Security.Policy.ApplicationTrust); } }
+    public System.Security.Policy.ApplicationTrust this[string appFullName] { get { return default(System.Security.Policy.ApplicationTrust); } }
+    public object SyncRoot { get { return default(object); } }
+    public int Add(System.Security.Policy.ApplicationTrust trust) { return default(int); }
+    public void AddRange(System.Security.Policy.ApplicationTrust[] trusts) { }
+    public void AddRange(System.Security.Policy.ApplicationTrustCollection trusts) { }
+    public void Clear() { }
+    public void CopyTo(System.Security.Policy.ApplicationTrust[] array, int index) { }
+    public System.Security.Policy.ApplicationTrustCollection Find(System.ApplicationIdentity applicationIdentity, System.Security.Policy.ApplicationVersionMatch versionMatch) { return default(System.Security.Policy.ApplicationTrustCollection); }
+    public System.Security.Policy.ApplicationTrustEnumerator GetEnumerator() { return default(System.Security.Policy.ApplicationTrustEnumerator); }
+    public void Remove(System.ApplicationIdentity applicationIdentity, System.Security.Policy.ApplicationVersionMatch versionMatch) { }
+    public void Remove(System.Security.Policy.ApplicationTrust trust) { }
+    public void RemoveRange(System.Security.Policy.ApplicationTrust[] trusts) { }
+    public void RemoveRange(System.Security.Policy.ApplicationTrustCollection trusts) { }
+    void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ApplicationTrustEnumerator : System.Collections.IEnumerator {
+    internal ApplicationTrustEnumerator() { }
+    public System.Security.Policy.ApplicationTrust Current { get { return default(System.Security.Policy.ApplicationTrust); } }
+    object System.Collections.IEnumerator.Current { get { return default(object); } }
+    public bool MoveNext() { return default(bool); }
+    public void Reset() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum ApplicationVersionMatch {
+    MatchAllVersions = 1,
+    MatchExactVersion = 0,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class CodeConnectAccess {
+    public static readonly string AnyScheme;
+    public static readonly int DefaultPort;
+    public static readonly int OriginPort;
+    public static readonly string OriginScheme;
+    public CodeConnectAccess(string allowScheme, int allowPort) { }
+    public int Port { get { return default(int); } }
+    public string Scheme { get { return default(string); } }
+    public static System.Security.Policy.CodeConnectAccess CreateAnySchemeAccess(int allowPort) { return default(System.Security.Policy.CodeConnectAccess); }
+    public static System.Security.Policy.CodeConnectAccess CreateOriginSchemeAccess(int allowPort) { return default(System.Security.Policy.CodeConnectAccess); }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class FirstMatchCodeGroup : System.Security.Policy.CodeGroup {
+    public FirstMatchCodeGroup(System.Security.Policy.IMembershipCondition membershipCondition, System.Security.Policy.PolicyStatement policy) : base (default(System.Security.Policy.IMembershipCondition), default(System.Security.Policy.PolicyStatement)) { }
+    public override string MergeLogic { get { return default(string); } }
+    public override System.Security.Policy.CodeGroup Copy() { return default(System.Security.Policy.CodeGroup); }
+    public override System.Security.Policy.PolicyStatement Resolve(System.Security.Policy.Evidence evidence) { return default(System.Security.Policy.PolicyStatement); }
+    public override System.Security.Policy.CodeGroup ResolveMatchingCodeGroups(System.Security.Policy.Evidence evidence) { return default(System.Security.Policy.CodeGroup); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class GacInstalled : System.Security.Policy.EvidenceBase, System.Security.Policy.IIdentityPermissionFactory {
+    public GacInstalled() { }
+    public object Copy() { return default(object); }
+    public System.Security.IPermission CreateIdentityPermission(System.Security.Policy.Evidence evidence) { return default(System.Security.IPermission); }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class GacMembershipCondition : System.Security.ISecurityEncodable, System.Security.ISecurityPolicyEncodable, System.Security.Policy.IMembershipCondition {
+    public GacMembershipCondition() { }
+    public bool Check(System.Security.Policy.Evidence evidence) { return default(bool); }
+    public System.Security.Policy.IMembershipCondition Copy() { return default(System.Security.Policy.IMembershipCondition); }
+    public override bool Equals(object o) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement e) { }
+    public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level) { return default(System.Security.SecurityElement); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Hash : System.Security.Policy.EvidenceBase, System.Runtime.Serialization.ISerializable {
+    public Hash(System.Reflection.Assembly assembly) { }
+    public byte[] MD5 { get { return default(byte[]); } }
+    public byte[] SHA1 { get { return default(byte[]); } }
+    public static System.Security.Policy.Hash CreateMD5(byte[] md5) { return default(System.Security.Policy.Hash); }
+    public static System.Security.Policy.Hash CreateSHA1(byte[] sha1) { return default(System.Security.Policy.Hash); }
+    public byte[] GenerateHash(System.Security.Cryptography.HashAlgorithm hashAlg) { return default(byte[]); }
+    public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class HashMembershipCondition : System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable, System.Security.ISecurityEncodable, System.Security.ISecurityPolicyEncodable, System.Security.Policy.IMembershipCondition {
+    public HashMembershipCondition(System.Security.Cryptography.HashAlgorithm hashAlg, byte[] value) { }
+    public System.Security.Cryptography.HashAlgorithm HashAlgorithm { get { return default(System.Security.Cryptography.HashAlgorithm); } set { } }
+    public byte[] HashValue { get { return default(byte[]); } set { } }
+    public bool Check(System.Security.Policy.Evidence evidence) { return default(bool); }
+    public System.Security.Policy.IMembershipCondition Copy() { return default(System.Security.Policy.IMembershipCondition); }
+    public override bool Equals(object o) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement e) { }
+    public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override int GetHashCode() { return default(int); }
+    void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level) { return default(System.Security.SecurityElement); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface IApplicationTrustManager : System.Security.ISecurityEncodable {
+    System.Security.Policy.ApplicationTrust DetermineApplicationTrust(System.ActivationContext activationContext, System.Security.Policy.TrustManagerContext context);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class NetCodeGroup : System.Security.Policy.CodeGroup {
+    public static readonly string AbsentOriginScheme;
+    public static readonly string AnyOtherOriginScheme;
+    public NetCodeGroup(System.Security.Policy.IMembershipCondition membershipCondition) : base (default(System.Security.Policy.IMembershipCondition), default(System.Security.Policy.PolicyStatement)) { }
+    public override string AttributeString { get { return default(string); } }
+    public override string MergeLogic { get { return default(string); } }
+    public override string PermissionSetName { get { return default(string); } }
+    public void AddConnectAccess(string originScheme, System.Security.Policy.CodeConnectAccess connectAccess) { }
+    public override System.Security.Policy.CodeGroup Copy() { return default(System.Security.Policy.CodeGroup); }
+    protected override void CreateXml(System.Security.SecurityElement element, System.Security.Policy.PolicyLevel level) { }
+    public override bool Equals(object o) { return default(bool); }
+    public System.Collections.DictionaryEntry[] GetConnectAccessRules() { return default(System.Collections.DictionaryEntry[]); }
+    public override int GetHashCode() { return default(int); }
+    protected override void ParseXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public void ResetConnectAccess() { }
+    public override System.Security.Policy.PolicyStatement Resolve(System.Security.Policy.Evidence evidence) { return default(System.Security.Policy.PolicyStatement); }
+    public override System.Security.Policy.CodeGroup ResolveMatchingCodeGroups(System.Security.Policy.Evidence evidence) { return default(System.Security.Policy.CodeGroup); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class PermissionRequestEvidence : System.Security.Policy.EvidenceBase {
+    public PermissionRequestEvidence(System.Security.PermissionSet request, System.Security.PermissionSet optional, System.Security.PermissionSet denied) { }
+    public System.Security.PermissionSet DeniedPermissions { get { return default(System.Security.PermissionSet); } }
+    public System.Security.PermissionSet OptionalPermissions { get { return default(System.Security.PermissionSet); } }
+    public System.Security.PermissionSet RequestedPermissions { get { return default(System.Security.PermissionSet); } }
+    public System.Security.Policy.PermissionRequestEvidence Copy() { return default(System.Security.Policy.PermissionRequestEvidence); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class PolicyException :System.SystemException{
+    public PolicyException() { }
+    protected PolicyException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public PolicyException(string message) { }
+    public PolicyException(string message, System.Exception exception) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Publisher : System.Security.Policy.EvidenceBase, System.Security.Policy.IIdentityPermissionFactory {
+    public Publisher(System.Security.Cryptography.X509Certificates.X509Certificate cert) { }
+    public System.Security.Cryptography.X509Certificates.X509Certificate Certificate { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } }
+    public object Copy() { return default(object); }
+    public System.Security.IPermission CreateIdentityPermission(System.Security.Policy.Evidence evidence) { return default(System.Security.IPermission); }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class PublisherMembershipCondition : System.Security.ISecurityEncodable, System.Security.ISecurityPolicyEncodable, System.Security.Policy.IMembershipCondition {
+    public PublisherMembershipCondition(System.Security.Cryptography.X509Certificates.X509Certificate certificate) { }
+    public System.Security.Cryptography.X509Certificates.X509Certificate Certificate { get { return default(System.Security.Cryptography.X509Certificates.X509Certificate); } set { } }
+    public bool Check(System.Security.Policy.Evidence evidence) { return default(bool); }
+    public System.Security.Policy.IMembershipCondition Copy() { return default(System.Security.Policy.IMembershipCondition); }
+    public override bool Equals(object o) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement e) { }
+    public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level) { return default(System.Security.SecurityElement); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Site : System.Security.Policy.EvidenceBase, System.Security.Policy.IIdentityPermissionFactory {
+    public Site(string name) { }
+    public string Name { get { return default(string); } }
+    public object Copy() { return default(object); }
+    public static System.Security.Policy.Site CreateFromUrl(string url) { return default(System.Security.Policy.Site); }
+    public System.Security.IPermission CreateIdentityPermission(System.Security.Policy.Evidence evidence) { return default(System.Security.IPermission); }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class SiteMembershipCondition : System.Security.ISecurityEncodable, System.Security.ISecurityPolicyEncodable, System.Security.Policy.IMembershipCondition {
+    public SiteMembershipCondition(string site) { }
+    public string Site { get { return default(string); } set { } }
+    public bool Check(System.Security.Policy.Evidence evidence) { return default(bool); }
+    public System.Security.Policy.IMembershipCondition Copy() { return default(System.Security.Policy.IMembershipCondition); }
+    public override bool Equals(object o) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement e) { }
+    public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level) { return default(System.Security.SecurityElement); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class UnionCodeGroup : System.Security.Policy.CodeGroup {
+    public UnionCodeGroup(System.Security.Policy.IMembershipCondition membershipCondition, System.Security.Policy.PolicyStatement policy) : base (default(System.Security.Policy.IMembershipCondition), default(System.Security.Policy.PolicyStatement)) { }
+    public override string MergeLogic { get { return default(string); } }
+    public override System.Security.Policy.CodeGroup Copy() { return default(System.Security.Policy.CodeGroup); }
+    public override System.Security.Policy.PolicyStatement Resolve(System.Security.Policy.Evidence evidence) { return default(System.Security.Policy.PolicyStatement); }
+    public override System.Security.Policy.CodeGroup ResolveMatchingCodeGroups(System.Security.Policy.Evidence evidence) { return default(System.Security.Policy.CodeGroup); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Url : System.Security.Policy.EvidenceBase, System.Security.Policy.IIdentityPermissionFactory {
+    public Url(string name) { }
+    public string Value { get { return default(string); } }
+    public object Copy() { return default(object); }
+    public System.Security.IPermission CreateIdentityPermission(System.Security.Policy.Evidence evidence) { return default(System.Security.IPermission); }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class UrlMembershipCondition : System.Security.ISecurityEncodable, System.Security.ISecurityPolicyEncodable, System.Security.Policy.IMembershipCondition {
+    public UrlMembershipCondition(string url) { }
+    public string Url { get { return default(string); } set { } }
+    public bool Check(System.Security.Policy.Evidence evidence) { return default(bool); }
+    public System.Security.Policy.IMembershipCondition Copy() { return default(System.Security.Policy.IMembershipCondition); }
+    public override bool Equals(object o) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement e) { }
+    public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level) { return default(System.Security.SecurityElement); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Zone : System.Security.Policy.EvidenceBase, System.Security.Policy.IIdentityPermissionFactory {
+    public Zone(System.Security.SecurityZone zone) { }
+    public System.Security.SecurityZone SecurityZone { get { return default(System.Security.SecurityZone); } }
+    public object Copy() { return default(object); }
+    public static System.Security.Policy.Zone CreateFromUrl(string url) { return default(System.Security.Policy.Zone); }
+    public System.Security.IPermission CreateIdentityPermission(System.Security.Policy.Evidence evidence) { return default(System.Security.IPermission); }
+    public override bool Equals(object o) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ZoneMembershipCondition : System.Security.ISecurityEncodable, System.Security.ISecurityPolicyEncodable, System.Security.Policy.IMembershipCondition {
+    public ZoneMembershipCondition(System.Security.SecurityZone zone) { }
+    public System.Security.SecurityZone SecurityZone { get { return default(System.Security.SecurityZone); } set { } }
+    public bool Check(System.Security.Policy.Evidence evidence) { return default(bool); }
+    public System.Security.Policy.IMembershipCondition Copy() { return default(System.Security.Policy.IMembershipCondition); }
+    public override bool Equals(object o) { return default(bool); }
+    public void FromXml(System.Security.SecurityElement e) { }
+    public void FromXml(System.Security.SecurityElement e, System.Security.Policy.PolicyLevel level) { }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+    public System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public System.Security.SecurityElement ToXml(System.Security.Policy.PolicyLevel level) { return default(System.Security.SecurityElement); }
+  }
+
+} // end of System.Security.Policy

fxdac/fxdac/Data/Contracts/System.Security.Principal.Windows.cs

@@ -0,0 +1,110 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Principal {
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public sealed partial class IdentityNotMappedException : System.SystemException {
+    public IdentityNotMappedException() { }
+    public IdentityNotMappedException(string message) { }
+    public IdentityNotMappedException(string message, System.Exception inner) { }
+    public System.Security.Principal.IdentityReferenceCollection UnmappedIdentities { get { return default(System.Security.Principal.IdentityReferenceCollection); } }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo serializationInfo, System.Runtime.Serialization.StreamingContext streamingContext) { }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum TokenAccessLevels {
+    AdjustDefault = 128,
+    AdjustGroups = 64,
+    AdjustPrivileges = 32,
+    AdjustSessionId = 256,
+    AllAccess = 983551,
+    AssignPrimary = 1,
+    Duplicate = 2,
+    Impersonate = 4,
+    MaximumAllowed = 33554432,
+    Query = 8,
+    QuerySource = 16,
+    Read = 131080,
+    Write = 131296,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum WindowsAccountType {
+    Anonymous = 3,
+    Guest = 1,
+    Normal = 0,
+    System = 2,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum WindowsBuiltInRole {
+    AccountOperator = 548,
+    Administrator = 544,
+    BackupOperator = 551,
+    Guest = 546,
+    PowerUser = 547,
+    PrintOperator = 550,
+    Replicator = 552,
+    SystemOperator = 549,
+    User = 545,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class WindowsIdentity : System.Security.Claims.ClaimsIdentity, System.IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable, System.Security.Principal.IIdentity {
+    public const string DefaultIssuer = "AD AUTHORITY";
+    public WindowsIdentity(System.IntPtr userToken) { }
+    public WindowsIdentity(System.IntPtr userToken, string type) { }
+    public WindowsIdentity(System.IntPtr userToken, string type, System.Security.Principal.WindowsAccountType acctType) { }
+    public WindowsIdentity(System.IntPtr userToken, string type, System.Security.Principal.WindowsAccountType acctType, bool isAuthenticated) { }
+    public WindowsIdentity(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public WindowsIdentity(string sUserPrincipalName) { }
+    public WindowsIdentity(string sUserPrincipalName, string type) { }
+    public sealed override string AuthenticationType { get { return default(string); } }
+    public System.Security.Principal.IdentityReferenceCollection Groups { get { return default(System.Security.Principal.IdentityReferenceCollection); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Security.Principal.TokenImpersonationLevel ImpersonationLevel { get { return default(System.Security.Principal.TokenImpersonationLevel); } }
+    public virtual bool IsAnonymous { get { return default(bool); } }
+    public override bool IsAuthenticated { get { return default(bool); } }
+    public virtual bool IsGuest { get { return default(bool); } }
+    public virtual bool IsSystem { get { return default(bool); } }
+    public override string Name { get { return default(string); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Security.Principal.SecurityIdentifier Owner { get { return default(System.Security.Principal.SecurityIdentifier); } }
+    public virtual System.IntPtr Token { get { return default(System.IntPtr); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Security.Principal.SecurityIdentifier User { get { return default(System.Security.Principal.SecurityIdentifier); } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void Dispose() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    protected virtual void Dispose(bool disposing) { }
+    public static System.Security.Principal.WindowsIdentity GetAnonymous() { return default(System.Security.Principal.WindowsIdentity); }
+    public static System.Security.Principal.WindowsIdentity GetCurrent() { return default(System.Security.Principal.WindowsIdentity); }
+    public static System.Security.Principal.WindowsIdentity GetCurrent(bool ifImpersonating) { return default(System.Security.Principal.WindowsIdentity); }
+    public static System.Security.Principal.WindowsIdentity GetCurrent(System.Security.Principal.TokenAccessLevels desiredAccess) { return default(System.Security.Principal.WindowsIdentity); }
+    public virtual System.Security.Principal.WindowsImpersonationContext Impersonate() { return default(System.Security.Principal.WindowsImpersonationContext); }
+    public static System.Security.Principal.WindowsImpersonationContext Impersonate(System.IntPtr userToken) { return default(System.Security.Principal.WindowsImpersonationContext); }
+    void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender) { }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class WindowsImpersonationContext : System.IDisposable {
+    internal WindowsImpersonationContext() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void Dispose() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    protected virtual void Dispose(bool disposing) { }
+    public void Undo() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class WindowsPrincipal : System.Security.Claims.ClaimsPrincipal {
+    public WindowsPrincipal(System.Security.Principal.WindowsIdentity ntIdentity) { }
+    public override System.Security.Principal.IIdentity Identity { get { return default(System.Security.Principal.IIdentity); } }
+    public virtual bool IsInRole(int rid) { return default(bool); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public virtual bool IsInRole(System.Security.Principal.SecurityIdentifier sid) { return default(bool); }
+    public virtual bool IsInRole(System.Security.Principal.WindowsBuiltInRole role) { return default(bool); }
+    public override bool IsInRole(string role) { return default(bool); }
+  }
+
+} // end of System.Security.Principal

fxdac/fxdac/Data/Contracts/System.Security.Principal.cs

@@ -0,0 +1,12 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.Principal {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum TokenImpersonationLevel {
+    Anonymous = 1,
+    Delegation = 4,
+    Identification = 2,
+    Impersonation = 3,
+    None = 0,
+  }
+
+} // end of System.Security.Principal

fxdac/fxdac/Data/Contracts/System.Security.TBD.cs

@@ -0,0 +1,186 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class HostProtectionException : System.SystemException {
+    public HostProtectionException() { }
+    protected HostProtectionException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public HostProtectionException(string message) { }
+    public HostProtectionException(string message, System.Exception e) { }
+    public HostProtectionException(string message, System.Security.Permissions.HostProtectionResource protectedResources, System.Security.Permissions.HostProtectionResource demandedResources) { }
+    public System.Security.Permissions.HostProtectionResource DemandedResources { get { return default(System.Security.Permissions.HostProtectionResource); } }
+    public System.Security.Permissions.HostProtectionResource ProtectedResources { get { return default(System.Security.Permissions.HostProtectionResource); } }
+    public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial interface IEvidenceFactory {
+    System.Security.Policy.Evidence Evidence { get; }
+  }
+
+  public sealed partial class SecurityContext : System.IDisposable {
+    internal SecurityContext() { }
+    public static System.Security.SecurityContext Capture() { return default(System.Security.SecurityContext); }
+    public System.Security.SecurityContext CreateCopy() { return default(System.Security.SecurityContext); }
+    public void Dispose() { }
+    public static bool IsFlowSuppressed() { return default(bool); }
+    public static bool IsWindowsIdentityFlowSuppressed() { return default(bool); }
+    public static void RestoreFlow() { }
+    public static void Run(System.Security.SecurityContext securityContext, System.Threading.ContextCallback callback, object state) { }
+    public static System.Threading.AsyncFlowControl SuppressFlow() { return default(System.Threading.AsyncFlowControl); }
+    public static System.Threading.AsyncFlowControl SuppressFlowWindowsIdentity() { return default(System.Threading.AsyncFlowControl); }
+  }
+
+  [System.ObsoleteAttribute("SecurityCriticalScope is only used for .NET 2.0 transparency compatibility.")]
+  public enum SecurityCriticalScope {
+    Everything = 1,
+    Explicit = 0,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public static partial class SecurityManager {
+    [System.ObsoleteAttribute]
+    public static bool CheckExecutionRights { get { return default(bool); } set { } }
+    [System.ObsoleteAttribute("The security manager cannot be turned off on MS runtime")]
+    public static bool SecurityEnabled { get { return default(bool); } set { } }
+    public static bool CurrentThreadRequiresSecurityContextCapture() { return default(bool); }
+    public static System.Security.PermissionSet GetStandardSandbox(System.Security.Policy.Evidence evidence) { return default(System.Security.PermissionSet); }
+    public static void GetZoneAndOrigin(out System.Collections.ArrayList zone, out System.Collections.ArrayList origin) { zone = default(System.Collections.ArrayList); origin = default(System.Collections.ArrayList); }
+    [System.ObsoleteAttribute]
+    public static bool IsGranted(System.Security.IPermission perm) { return default(bool); }
+    [System.ObsoleteAttribute]
+    public static System.Security.Policy.PolicyLevel LoadPolicyLevelFromFile(string path, System.Security.PolicyLevelType type) { return default(System.Security.Policy.PolicyLevel); }
+    [System.ObsoleteAttribute]
+    public static System.Security.Policy.PolicyLevel LoadPolicyLevelFromString(string str, System.Security.PolicyLevelType type) { return default(System.Security.Policy.PolicyLevel); }
+    [System.ObsoleteAttribute]
+    public static System.Collections.IEnumerator PolicyHierarchy() { return default(System.Collections.IEnumerator); }
+    [System.ObsoleteAttribute]
+    public static System.Security.PermissionSet ResolvePolicy(System.Security.Policy.Evidence evidence) { return default(System.Security.PermissionSet); }
+    [System.ObsoleteAttribute]
+    public static System.Security.PermissionSet ResolvePolicy(System.Security.Policy.Evidence evidence, System.Security.PermissionSet reqdPset, System.Security.PermissionSet optPset, System.Security.PermissionSet denyPset, out System.Security.PermissionSet denied) { denied = default(System.Security.PermissionSet); return default(System.Security.PermissionSet); }
+    [System.ObsoleteAttribute]
+    public static System.Security.PermissionSet ResolvePolicy(System.Security.Policy.Evidence[] evidences) { return default(System.Security.PermissionSet); }
+    [System.ObsoleteAttribute]
+    public static System.Collections.IEnumerator ResolvePolicyGroups(System.Security.Policy.Evidence evidence) { return default(System.Collections.IEnumerator); }
+    [System.ObsoleteAttribute]
+    public static System.Security.PermissionSet ResolveSystemPolicy(System.Security.Policy.Evidence evidence) { return default(System.Security.PermissionSet); }
+    [System.ObsoleteAttribute]
+    public static void SavePolicy() { }
+    [System.ObsoleteAttribute]
+    public static void SavePolicyLevel(System.Security.Policy.PolicyLevel level) { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(1), AllowMultiple=false)]
+  public sealed partial class SecurityRulesAttribute : System.Attribute {
+    public SecurityRulesAttribute(System.Security.SecurityRuleSet ruleSet) { }
+    public System.Security.SecurityRuleSet RuleSet { get { return default(System.Security.SecurityRuleSet); } }
+    public bool SkipVerificationInFullTrust { get { return default(bool); } set { } }
+  }
+
+  public enum SecurityRuleSet : byte {
+    Level1 = (byte)1,
+    Level2 = (byte)2,
+    None = (byte)0,
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(5501), AllowMultiple=false, Inherited=false)]
+  [System.ObsoleteAttribute("SecurityTreatAsSafe is only used for .NET 2.0 transparency compatibility.  Please use the SecuritySafeCriticalAttribute instead.")]
+  public sealed partial class SecurityTreatAsSafeAttribute : System.Attribute {
+    public SecurityTreatAsSafeAttribute() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(2), AllowMultiple=true, Inherited=false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class UnverifiableCodeAttribute : System.Attribute {
+    public UnverifiableCodeAttribute() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class XmlSyntaxException : System.SystemException {
+    public XmlSyntaxException() { }
+    public XmlSyntaxException(int lineNumber) { }
+    public XmlSyntaxException(int lineNumber, string message) { }
+    public XmlSyntaxException(string message) { }
+    public XmlSyntaxException(string message, System.Exception inner) { }
+  }
+
+} // end of System.Security
+namespace System.Security.Cryptography {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class CryptoAPITransform : System.IDisposable, System.Security.Cryptography.ICryptoTransform {
+    internal CryptoAPITransform() { }
+    public bool CanReuseTransform { get { return default(bool); } }
+    public bool CanTransformMultipleBlocks { get { return default(bool); } }
+    public int InputBlockSize { get { return default(int); } }
+    public System.IntPtr KeyHandle { get { return default(System.IntPtr); } }
+    public int OutputBlockSize { get { return default(int); } }
+    public void Clear() { }
+    public void Dispose() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public void Reset() { }
+    public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) { return default(int); }
+    public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { return default(byte[]); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class CryptoConfig {
+    public CryptoConfig() { }
+    public static bool AllowOnlyFipsAlgorithms { get { return default(bool); } }
+    public static object CreateFromName(string name) { return default(object); }
+    public static object CreateFromName(string name, params object[] args) { return default(object); }
+    public static byte[] EncodeOID(string str) { return default(byte[]); }
+    public static string MapNameToOID(string name) { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class FromBase64Transform : System.IDisposable, System.Security.Cryptography.ICryptoTransform {
+    public FromBase64Transform() { }
+    public FromBase64Transform(System.Security.Cryptography.FromBase64TransformMode whitespaces) { }
+    public virtual bool CanReuseTransform { get { return default(bool); } }
+    public bool CanTransformMultipleBlocks { get { return default(bool); } }
+    public int InputBlockSize { get { return default(int); } }
+    public int OutputBlockSize { get { return default(int); } }
+    public void Clear() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    ~FromBase64Transform() { }
+    public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) { return default(int); }
+    public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { return default(byte[]); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum FromBase64TransformMode {
+    DoNotIgnoreWhiteSpaces = 1,
+    IgnoreWhiteSpaces = 0,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public abstract partial class MaskGenerationMethod {
+    protected MaskGenerationMethod() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+    public abstract byte[] GenerateMask(byte[] rgbSeed, int cbReturn);
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class PKCS1MaskGenerationMethod : System.Security.Cryptography.MaskGenerationMethod {
+    public PKCS1MaskGenerationMethod() { }
+    public string HashName { get { return default(string); } set { } }
+    public override byte[] GenerateMask(byte[] rgbSeed, int cbReturn) { return default(byte[]); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ToBase64Transform : System.IDisposable, System.Security.Cryptography.ICryptoTransform {
+    public ToBase64Transform() { }
+    public virtual bool CanReuseTransform { get { return default(bool); } }
+    public bool CanTransformMultipleBlocks { get { return default(bool); } }
+    public int InputBlockSize { get { return default(int); } }
+    public int OutputBlockSize { get { return default(int); } }
+    public void Clear() { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    ~ToBase64Transform() { }
+    public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) { return default(int); }
+    public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { return default(byte[]); }
+  }
+
+} // end of System.Security.Cryptography

fxdac/fxdac/Data/Contracts/System.Text.Encoding.Extensions.cs

@@ -0,0 +1,224 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Text {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ASCIIEncoding : System.Text.Encoding {
+    public ASCIIEncoding() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override bool IsSingleByte { get { return default(bool); } }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetByteCount(char* chars, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(char[] chars, int index, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(string chars) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(string chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetCharCount(byte* bytes, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetCharCount(byte[] bytes, int index, int count) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Text.Decoder GetDecoder() { return default(System.Text.Decoder); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Text.Encoder GetEncoder() { return default(System.Text.Encoder); }
+    public override int GetMaxByteCount(int charCount) { return default(int); }
+    public override int GetMaxCharCount(int byteCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override string GetString(byte[] bytes, int byteIndex, int byteCount) { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class UnicodeEncoding : System.Text.Encoding {
+    public const int CharSize = 2;
+    public UnicodeEncoding() { }
+    public UnicodeEncoding(bool bigEndian, bool byteOrderMark) { }
+    public UnicodeEncoding(bool bigEndian, bool byteOrderMark, bool throwOnInvalidBytes) { }
+    public override bool Equals(object value) { return default(bool); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetByteCount(char* chars, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(char[] chars, int index, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(string s) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetCharCount(byte* bytes, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetCharCount(byte[] bytes, int index, int count) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) { return default(int); }
+    public override System.Text.Decoder GetDecoder() { return default(System.Text.Decoder); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override System.Text.Encoder GetEncoder() { return default(System.Text.Encoder); }
+    public override int GetHashCode() { return default(int); }
+    public override int GetMaxByteCount(int charCount) { return default(int); }
+    public override int GetMaxCharCount(int byteCount) { return default(int); }
+    public override byte[] GetPreamble() { return default(byte[]); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override string GetString(byte[] bytes, int index, int count) { return default(string); }
+  }
+
+  public sealed partial class UTF32Encoding : System.Text.Encoding {
+    public UTF32Encoding() { }
+    public UTF32Encoding(bool bigEndian, bool byteOrderMark) { }
+    public UTF32Encoding(bool bigEndian, bool byteOrderMark, bool throwOnInvalidCharacters) { }
+    public override bool Equals(object value) { return default(bool); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetByteCount(char* chars, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(char[] chars, int index, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(string s) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetCharCount(byte* bytes, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetCharCount(byte[] bytes, int index, int count) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) { return default(int); }
+    public override System.Text.Decoder GetDecoder() { return default(System.Text.Decoder); }
+    public override System.Text.Encoder GetEncoder() { return default(System.Text.Encoder); }
+    public override int GetHashCode() { return default(int); }
+    public override int GetMaxByteCount(int charCount) { return default(int); }
+    public override int GetMaxCharCount(int byteCount) { return default(int); }
+    public override byte[] GetPreamble() { return default(byte[]); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override string GetString(byte[] bytes, int index, int count) { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class UTF7Encoding : System.Text.Encoding {
+    public UTF7Encoding() { }
+    public UTF7Encoding(bool allowOptionals) { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override bool Equals(object value) { return default(bool); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetByteCount(char* chars, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(char[] chars, int index, int count) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(string s) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetCharCount(byte* bytes, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetCharCount(byte[] bytes, int index, int count) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) { return default(int); }
+    public override System.Text.Decoder GetDecoder() { return default(System.Text.Decoder); }
+    public override System.Text.Encoder GetEncoder() { return default(System.Text.Encoder); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetHashCode() { return default(int); }
+    public override int GetMaxByteCount(int charCount) { return default(int); }
+    public override int GetMaxCharCount(int byteCount) { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override string GetString(byte[] bytes, int index, int count) { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class UTF8Encoding : System.Text.Encoding {
+    public UTF8Encoding() { }
+    public UTF8Encoding(bool encoderShouldEmitUTF8Identifier) { }
+    public UTF8Encoding(bool encoderShouldEmitUTF8Identifier, bool throwOnInvalidBytes) { }
+    public override bool Equals(object value) { return default(bool); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetByteCount(char* chars, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(char[] chars, int index, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetByteCount(string chars) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetCharCount(byte* bytes, int count) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetCharCount(byte[] bytes, int index, int count) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount) { return default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) { return default(int); }
+    public override System.Text.Decoder GetDecoder() { return default(System.Text.Decoder); }
+    public override System.Text.Encoder GetEncoder() { return default(System.Text.Encoder); }
+    public override int GetHashCode() { return default(int); }
+    public override int GetMaxByteCount(int charCount) { return default(int); }
+    public override int GetMaxCharCount(int byteCount) { return default(int); }
+    public override byte[] GetPreamble() { return default(byte[]); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override string GetString(byte[] bytes, int index, int count) { return default(string); }
+  }
+
+} // end of System.Text

fxdac/fxdac/Data/Contracts/System.Text.Encoding.cs

@@ -0,0 +1,98 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Text {
+  public sealed partial class DecoderExceptionFallback : System.Text.DecoderFallback {
+    public DecoderExceptionFallback() { }
+    public override int MaxCharCount { get { return default(int); } }
+    public override System.Text.DecoderFallbackBuffer CreateFallbackBuffer() { return default(System.Text.DecoderFallbackBuffer); }
+    public override bool Equals(object value) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+  }
+
+  public sealed partial class DecoderExceptionFallbackBuffer : System.Text.DecoderFallbackBuffer {
+    public DecoderExceptionFallbackBuffer() { }
+    public override int Remaining { get { return default(int); } }
+    public override bool Fallback(byte[] bytesUnknown, int index) { return default(bool); }
+    public override char GetNextChar() { return default(char); }
+    public override bool MovePrevious() { return default(bool); }
+  }
+
+  public sealed partial class DecoderFallbackException : System.ArgumentException {
+    public DecoderFallbackException() { }
+    public DecoderFallbackException(string message) { }
+    public DecoderFallbackException(string message, byte[] bytesUnknown, int index) { }
+    public DecoderFallbackException(string message, System.Exception innerException) { }
+    public byte[] BytesUnknown { get { return default(byte[]); } }
+    public int Index { get { return default(int); } }
+  }
+
+  public sealed partial class DecoderReplacementFallback : System.Text.DecoderFallback {
+    public DecoderReplacementFallback() { }
+    public DecoderReplacementFallback(string replacement) { }
+    public string DefaultString { get { return default(string); } }
+    public override int MaxCharCount { get { return default(int); } }
+    public override System.Text.DecoderFallbackBuffer CreateFallbackBuffer() { return default(System.Text.DecoderFallbackBuffer); }
+    public override bool Equals(object value) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+  }
+
+  public sealed partial class DecoderReplacementFallbackBuffer : System.Text.DecoderFallbackBuffer {
+    public DecoderReplacementFallbackBuffer(System.Text.DecoderReplacementFallback fallback) { }
+    public override int Remaining { get { return default(int); } }
+    public override bool Fallback(byte[] bytesUnknown, int index) { return default(bool); }
+    public override char GetNextChar() { return default(char); }
+    public override bool MovePrevious() { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override void Reset() { }
+  }
+
+  public sealed partial class EncoderExceptionFallback : System.Text.EncoderFallback {
+    public EncoderExceptionFallback() { }
+    public override int MaxCharCount { get { return default(int); } }
+    public override System.Text.EncoderFallbackBuffer CreateFallbackBuffer() { return default(System.Text.EncoderFallbackBuffer); }
+    public override bool Equals(object value) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+  }
+
+  public sealed partial class EncoderExceptionFallbackBuffer : System.Text.EncoderFallbackBuffer {
+    public EncoderExceptionFallbackBuffer() { }
+    public override int Remaining { get { return default(int); } }
+    public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index) { return default(bool); }
+    public override bool Fallback(char charUnknown, int index) { return default(bool); }
+    public override char GetNextChar() { return default(char); }
+    public override bool MovePrevious() { return default(bool); }
+  }
+
+  public sealed partial class EncoderFallbackException : System.ArgumentException {
+    public EncoderFallbackException() { }
+    public EncoderFallbackException(string message) { }
+    public EncoderFallbackException(string message, System.Exception innerException) { }
+    public char CharUnknown { get { return default(char); } }
+    public char CharUnknownHigh { get { return default(char); } }
+    public char CharUnknownLow { get { return default(char); } }
+    public int Index { get { return default(int); } }
+    public bool IsUnknownSurrogate() { return default(bool); }
+  }
+
+  public sealed partial class EncoderReplacementFallback : System.Text.EncoderFallback {
+    public EncoderReplacementFallback() { }
+    public EncoderReplacementFallback(string replacement) { }
+    public string DefaultString { get { return default(string); } }
+    public override int MaxCharCount { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(int); } }
+    public override System.Text.EncoderFallbackBuffer CreateFallbackBuffer() { return default(System.Text.EncoderFallbackBuffer); }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public override bool Equals(object value) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+  }
+
+  public sealed partial class EncoderReplacementFallbackBuffer : System.Text.EncoderFallbackBuffer {
+    public EncoderReplacementFallbackBuffer(System.Text.EncoderReplacementFallback fallback) { }
+    public override int Remaining { get { return default(int); } }
+    public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index) { return default(bool); }
+    public override bool Fallback(char charUnknown, int index) { return default(bool); }
+    public override char GetNextChar() { return default(char); }
+    public override bool MovePrevious() { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public override void Reset() { }
+  }
+
+} // end of System.Text

fxdac/fxdac/Data/Contracts/System.Text.RegularExpressions.cs

@@ -0,0 +1,215 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Text.RegularExpressions {
+  public partial class Capture {
+    internal Capture() { }
+    public int Index { get { return default(int); } }
+    public int Length { get { return default(int); } }
+    public string Value { get { return default(string); } }
+    public override string ToString() { return default(string); }
+  }
+
+  public partial class CaptureCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    internal CaptureCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Text.RegularExpressions.Capture this[int i] { get { return default(System.Text.RegularExpressions.Capture); } }
+    public object SyncRoot { get { return default(object); } }
+    public void CopyTo(System.Array array, int arrayIndex) { }
+    public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public partial class Group : System.Text.RegularExpressions.Capture {
+    internal Group() { }
+    public System.Text.RegularExpressions.CaptureCollection Captures { get { return default(System.Text.RegularExpressions.CaptureCollection); } }
+    public bool Success { get { return default(bool); } }
+    public static System.Text.RegularExpressions.Group Synchronized(System.Text.RegularExpressions.Group inner) { return default(System.Text.RegularExpressions.Group); }
+  }
+
+  public partial class GroupCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    internal GroupCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public System.Text.RegularExpressions.Group this[int groupnum] { get { return default(System.Text.RegularExpressions.Group); } }
+    public System.Text.RegularExpressions.Group this[string groupname] { get { return default(System.Text.RegularExpressions.Group); } }
+    public object SyncRoot { get { return default(object); } }
+    public void CopyTo(System.Array array, int arrayIndex) { }
+    public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public partial class Match : System.Text.RegularExpressions.Group {
+    internal Match() { }
+    public static System.Text.RegularExpressions.Match Empty { get { return default(System.Text.RegularExpressions.Match); } }
+    public virtual System.Text.RegularExpressions.GroupCollection Groups { get { return default(System.Text.RegularExpressions.GroupCollection); } }
+    public System.Text.RegularExpressions.Match NextMatch() { return default(System.Text.RegularExpressions.Match); }
+    public virtual string Result(string replacement) { return default(string); }
+    public static System.Text.RegularExpressions.Match Synchronized(System.Text.RegularExpressions.Match inner) { return default(System.Text.RegularExpressions.Match); }
+  }
+
+  public partial class MatchCollection : System.Collections.ICollection, System.Collections.IEnumerable {
+    internal MatchCollection() { }
+    public int Count { get { return default(int); } }
+    public bool IsReadOnly { get { return default(bool); } }
+    public bool IsSynchronized { get { return default(bool); } }
+    public virtual System.Text.RegularExpressions.Match this[int i] { get { return default(System.Text.RegularExpressions.Match); } }
+    public object SyncRoot { get { return default(object); } }
+    public void CopyTo(System.Array array, int arrayIndex) { }
+    public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
+  }
+
+  public delegate string MatchEvaluator(System.Text.RegularExpressions.Match match);
+
+  public partial class Regex : System.Runtime.Serialization.ISerializable {
+    protected internal System.Collections.Hashtable capnames;
+    protected internal System.Collections.Hashtable caps;
+    protected internal int capsize;
+    protected internal string[] capslist;
+    protected internal System.Text.RegularExpressions.RegexRunnerFactory factory;
+    public static readonly System.TimeSpan InfiniteMatchTimeout;
+    [System.Runtime.Serialization.OptionalFieldAttribute(VersionAdded=2)]
+    protected internal System.TimeSpan internalMatchTimeout;
+    protected internal string pattern;
+    protected internal System.Text.RegularExpressions.RegexOptions roptions;
+    protected Regex() { }
+    protected Regex(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public Regex(string pattern) { }
+    public Regex(string pattern, System.Text.RegularExpressions.RegexOptions options) { }
+    public Regex(string pattern, System.Text.RegularExpressions.RegexOptions options, System.TimeSpan matchTimeout) { }
+    public static int CacheSize { get { return default(int); } set { } }
+    public System.TimeSpan MatchTimeout { get { return default(System.TimeSpan); } }
+    public System.Text.RegularExpressions.RegexOptions Options { get { return default(System.Text.RegularExpressions.RegexOptions); } }
+    public bool RightToLeft { get { return default(bool); } }
+    public static string Escape(string str) { return default(string); }
+    public string[] GetGroupNames() { return default(string[]); }
+    public int[] GetGroupNumbers() { return default(int[]); }
+    public string GroupNameFromNumber(int i) { return default(string); }
+    public int GroupNumberFromName(string name) { return default(int); }
+    protected void InitializeReferences() { }
+    public bool IsMatch(string input) { return default(bool); }
+    public bool IsMatch(string input, int startat) { return default(bool); }
+    public static bool IsMatch(string input, string pattern) { return default(bool); }
+    public static bool IsMatch(string input, string pattern, System.Text.RegularExpressions.RegexOptions options) { return default(bool); }
+    public static bool IsMatch(string input, string pattern, System.Text.RegularExpressions.RegexOptions options, System.TimeSpan matchTimeout) { return default(bool); }
+    public System.Text.RegularExpressions.Match Match(string input) { return default(System.Text.RegularExpressions.Match); }
+    public System.Text.RegularExpressions.Match Match(string input, int startat) { return default(System.Text.RegularExpressions.Match); }
+    public System.Text.RegularExpressions.Match Match(string input, int beginning, int length) { return default(System.Text.RegularExpressions.Match); }
+    public static System.Text.RegularExpressions.Match Match(string input, string pattern) { return default(System.Text.RegularExpressions.Match); }
+    public static System.Text.RegularExpressions.Match Match(string input, string pattern, System.Text.RegularExpressions.RegexOptions options) { return default(System.Text.RegularExpressions.Match); }
+    public static System.Text.RegularExpressions.Match Match(string input, string pattern, System.Text.RegularExpressions.RegexOptions options, System.TimeSpan matchTimeout) { return default(System.Text.RegularExpressions.Match); }
+    public System.Text.RegularExpressions.MatchCollection Matches(string input) { return default(System.Text.RegularExpressions.MatchCollection); }
+    public System.Text.RegularExpressions.MatchCollection Matches(string input, int startat) { return default(System.Text.RegularExpressions.MatchCollection); }
+    public static System.Text.RegularExpressions.MatchCollection Matches(string input, string pattern) { return default(System.Text.RegularExpressions.MatchCollection); }
+    public static System.Text.RegularExpressions.MatchCollection Matches(string input, string pattern, System.Text.RegularExpressions.RegexOptions options) { return default(System.Text.RegularExpressions.MatchCollection); }
+    public static System.Text.RegularExpressions.MatchCollection Matches(string input, string pattern, System.Text.RegularExpressions.RegexOptions options, System.TimeSpan matchTimeout) { return default(System.Text.RegularExpressions.MatchCollection); }
+    public string Replace(string input, string replacement) { return default(string); }
+    public string Replace(string input, string replacement, int count) { return default(string); }
+    public string Replace(string input, string replacement, int count, int startat) { return default(string); }
+    public static string Replace(string input, string pattern, string replacement) { return default(string); }
+    public static string Replace(string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options) { return default(string); }
+    public static string Replace(string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, System.TimeSpan matchTimeout) { return default(string); }
+    public static string Replace(string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator) { return default(string); }
+    public static string Replace(string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options) { return default(string); }
+    public static string Replace(string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options, System.TimeSpan matchTimeout) { return default(string); }
+    public string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator) { return default(string); }
+    public string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count) { return default(string); }
+    public string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat) { return default(string); }
+    public string[] Split(string input) { return default(string[]); }
+    public string[] Split(string input, int count) { return default(string[]); }
+    public string[] Split(string input, int count, int startat) { return default(string[]); }
+    public static string[] Split(string input, string pattern) { return default(string[]); }
+    public static string[] Split(string input, string pattern, System.Text.RegularExpressions.RegexOptions options) { return default(string[]); }
+    public static string[] Split(string input, string pattern, System.Text.RegularExpressions.RegexOptions options, System.TimeSpan matchTimeout) { return default(string[]); }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo si, System.Runtime.Serialization.StreamingContext context) { }
+    public override string ToString() { return default(string); }
+    public static string Unescape(string str) { return default(string); }
+    protected bool UseOptionR() { return default(bool); }
+    protected internal static void ValidateMatchTimeout(System.TimeSpan matchTimeout) { }
+  }
+
+  public partial class RegexCompilationInfo {
+    public RegexCompilationInfo(string pattern, System.Text.RegularExpressions.RegexOptions options, string name, string fullnamespace, bool ispublic) { }
+    public RegexCompilationInfo(string pattern, System.Text.RegularExpressions.RegexOptions options, string name, string fullnamespace, bool ispublic, System.TimeSpan matchTimeout) { }
+    public bool IsPublic { get { return default(bool); } set { } }
+    public System.TimeSpan MatchTimeout { get { return default(System.TimeSpan); } set { } }
+    public string Name { get { return default(string); } set { } }
+    public string Namespace { get { return default(string); } set { } }
+    public System.Text.RegularExpressions.RegexOptions Options { get { return default(System.Text.RegularExpressions.RegexOptions); } set { } }
+    public string Pattern { get { return default(string); } set { } }
+  }
+
+  public partial class RegexMatchTimeoutException : System.TimeoutException, System.Runtime.Serialization.ISerializable {
+    public RegexMatchTimeoutException() { }
+    protected RegexMatchTimeoutException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public RegexMatchTimeoutException(string message) { }
+    public RegexMatchTimeoutException(string message, System.Exception inner) { }
+    public RegexMatchTimeoutException(string regexInput, string regexPattern, System.TimeSpan matchTimeout) { }
+    public string Input { get { return default(string); } }
+    public System.TimeSpan MatchTimeout { get { return default(System.TimeSpan); } }
+    public string Pattern { get { return default(string); } }
+    void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo si, System.Runtime.Serialization.StreamingContext context) { }
+  }
+
+  [System.FlagsAttribute]
+  public enum RegexOptions {
+    Compiled = 8,
+    CultureInvariant = 512,
+    ECMAScript = 256,
+    ExplicitCapture = 4,
+    IgnoreCase = 1,
+    IgnorePatternWhitespace = 32,
+    Multiline = 2,
+    None = 0,
+    RightToLeft = 64,
+    Singleline = 16,
+  }
+
+  [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+  public abstract partial class RegexRunner {
+    protected internal int[] runcrawl;
+    protected internal int runcrawlpos;
+    protected internal System.Text.RegularExpressions.Match runmatch;
+    protected internal System.Text.RegularExpressions.Regex runregex;
+    protected internal int[] runstack;
+    protected internal int runstackpos;
+    protected internal string runtext;
+    protected internal int runtextbeg;
+    protected internal int runtextend;
+    protected internal int runtextpos;
+    protected internal int runtextstart;
+    protected internal int[] runtrack;
+    protected internal int runtrackcount;
+    protected internal int runtrackpos;
+    protected internal RegexRunner() { }
+    protected void Capture(int capnum, int start, int end) { }
+    protected static bool CharInClass(char ch, string charClass) { return default(bool); }
+    protected static bool CharInSet(char ch, string @set, string category) { return default(bool); }
+    protected void CheckTimeout() { }
+    protected void Crawl(int i) { }
+    protected int Crawlpos() { return default(int); }
+    protected void DoubleCrawl() { }
+    protected void DoubleStack() { }
+    protected void DoubleTrack() { }
+    protected void EnsureStorage() { }
+    protected abstract bool FindFirstChar();
+    protected abstract void Go();
+    protected abstract void InitTrackCount();
+    protected bool IsBoundary(int index, int startpos, int endpos) { return default(bool); }
+    protected bool IsECMABoundary(int index, int startpos, int endpos) { return default(bool); }
+    protected bool IsMatched(int cap) { return default(bool); }
+    protected int MatchIndex(int cap) { return default(int); }
+    protected int MatchLength(int cap) { return default(int); }
+    protected int Popcrawl() { return default(int); }
+    protected internal System.Text.RegularExpressions.Match Scan(System.Text.RegularExpressions.Regex regex, string text, int textbeg, int textend, int textstart, int prevlen, bool quick) { return default(System.Text.RegularExpressions.Match); }
+    protected internal System.Text.RegularExpressions.Match Scan(System.Text.RegularExpressions.Regex regex, string text, int textbeg, int textend, int textstart, int prevlen, bool quick, System.TimeSpan timeout) { return default(System.Text.RegularExpressions.Match); }
+    protected void TransferCapture(int capnum, int uncapnum, int start, int end) { }
+    protected void Uncapture() { }
+  }
+
+  [System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
+  public abstract partial class RegexRunnerFactory {
+    protected RegexRunnerFactory() { }
+    protected internal abstract System.Text.RegularExpressions.RegexRunner CreateInstance();
+  }
+
+} // end of System.Text.RegularExpressions

fxdac/fxdac/Data/Contracts/System.Threading.Overlapped.cs

@@ -0,0 +1,49 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Threading {
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Security.SecurityCriticalAttribute]
+  public unsafe delegate void IOCompletionCallback(uint errorCode, uint numBytes, System.Threading.NativeOverlapped* pOVERLAP);
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct NativeOverlapped {
+    public System.IntPtr EventHandle;
+    public System.IntPtr InternalHigh;
+    public System.IntPtr InternalLow;
+    public int OffsetHigh;
+    public int OffsetLow;
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class Overlapped {
+    public Overlapped() { }
+    [System.ObsoleteAttribute("Not 64bit compatible.  Please use the constructor that takes IntPtr for the event handle")]
+    public Overlapped(int offsetLo, int offsetHi, int hEvent, System.IAsyncResult ar) { }
+    public Overlapped(int offsetLo, int offsetHi, System.IntPtr hEvent, System.IAsyncResult ar) { }
+    public System.IAsyncResult AsyncResult { get { return default(System.IAsyncResult); } set { } }
+    [System.ObsoleteAttribute("Not 64bit compatible.  Use EventHandleIntPtr instead.")]
+    public int EventHandle { get { return default(int); } set { } }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.IntPtr EventHandleIntPtr { get { return default(System.IntPtr); } set { } }
+    public int OffsetHigh { get { return default(int); } set { } }
+    public int OffsetLow { get { return default(int); } set { } }
+    [System.CLSCompliantAttribute(false)]
+    public unsafe static void Free(System.Threading.NativeOverlapped* nativeOverlappedPtr) { }
+    [System.CLSCompliantAttribute(false)]
+    [System.ObsoleteAttribute("Use Pack(iocb, userData) instead")]
+    public unsafe System.Threading.NativeOverlapped* Pack(System.Threading.IOCompletionCallback iocb) { return default(System.Threading.NativeOverlapped*); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public unsafe System.Threading.NativeOverlapped* Pack(System.Threading.IOCompletionCallback iocb, object userData) { return default(System.Threading.NativeOverlapped*); }
+    [System.CLSCompliantAttribute(false)]
+    public unsafe static System.Threading.Overlapped Unpack(System.Threading.NativeOverlapped* nativeOverlappedPtr) { return default(System.Threading.Overlapped); }
+    [System.CLSCompliantAttribute(false)]
+    [System.ObsoleteAttribute("Use UnsafePack(iocb, userData) instead")]
+    public unsafe System.Threading.NativeOverlapped* UnsafePack(System.Threading.IOCompletionCallback iocb) { return default(System.Threading.NativeOverlapped*); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public unsafe System.Threading.NativeOverlapped* UnsafePack(System.Threading.IOCompletionCallback iocb, object userData) { return default(System.Threading.NativeOverlapped*); }
+  }
+
+} // end of System.Threading

fxdac/fxdac/Data/Contracts/System.Threading.Security.cs

@@ -0,0 +1,79 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.AccessControl {
+  public sealed partial class EventWaitHandleSecurity : System.Security.AccessControl.NativeObjectSecurity {
+    public EventWaitHandleSecurity() : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public override System.Type AccessRightType { get { return default(System.Type); } }
+    public override System.Type AccessRuleType { get { return default(System.Type); } }
+    public override System.Type AuditRuleType { get { return default(System.Type); } }
+    public override System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) { return default(System.Security.AccessControl.AccessRule); }
+    public void AddAccessRule(System.Security.AccessControl.EventWaitHandleAccessRule rule) { }
+    public void AddAuditRule(System.Security.AccessControl.EventWaitHandleAuditRule rule) { }
+    public override System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) { return default(System.Security.AccessControl.AuditRule); }
+    public bool RemoveAccessRule(System.Security.AccessControl.EventWaitHandleAccessRule rule) { return default(bool); }
+    public void RemoveAccessRuleAll(System.Security.AccessControl.EventWaitHandleAccessRule rule) { }
+    public void RemoveAccessRuleSpecific(System.Security.AccessControl.EventWaitHandleAccessRule rule) { }
+    public bool RemoveAuditRule(System.Security.AccessControl.EventWaitHandleAuditRule rule) { return default(bool); }
+    public void RemoveAuditRuleAll(System.Security.AccessControl.EventWaitHandleAuditRule rule) { }
+    public void RemoveAuditRuleSpecific(System.Security.AccessControl.EventWaitHandleAuditRule rule) { }
+    public void ResetAccessRule(System.Security.AccessControl.EventWaitHandleAccessRule rule) { }
+    public void SetAccessRule(System.Security.AccessControl.EventWaitHandleAccessRule rule) { }
+    public void SetAuditRule(System.Security.AccessControl.EventWaitHandleAuditRule rule) { }
+  }
+
+} // end of System.Security.AccessControl
+namespace System.Threading {
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class AbandonedMutexException : System.SystemException {
+    public AbandonedMutexException() { }
+    public AbandonedMutexException(int location, System.Threading.WaitHandle handle) { }
+    protected AbandonedMutexException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public AbandonedMutexException(string message) { }
+    public AbandonedMutexException(string message, System.Exception inner) { }
+    public AbandonedMutexException(string message, System.Exception inner, int location, System.Threading.WaitHandle handle) { }
+    public AbandonedMutexException(string message, int location, System.Threading.WaitHandle handle) { }
+    public System.Threading.Mutex Mutex { get { return default(System.Threading.Mutex); } }
+    public int MutexIndex { get { return default(int); } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class AutoResetEvent : System.Threading.EventWaitHandle {
+    public AutoResetEvent(bool initialState) : base (default(bool), default(System.Threading.EventResetMode)) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class EventWaitHandle : System.Threading.WaitHandle {
+    public EventWaitHandle(bool initialState, System.Threading.EventResetMode mode) { }
+    public EventWaitHandle(bool initialState, System.Threading.EventResetMode mode, string name) { }
+    public EventWaitHandle(bool initialState, System.Threading.EventResetMode mode, string name, out bool createdNew) { createdNew = default(bool); }
+    public EventWaitHandle(bool initialState, System.Threading.EventResetMode mode, string name, out bool createdNew, System.Security.AccessControl.EventWaitHandleSecurity eventSecurity) { createdNew = default(bool); }
+    public static System.Threading.EventWaitHandle OpenExisting(string name) { return default(System.Threading.EventWaitHandle); }
+    public static System.Threading.EventWaitHandle OpenExisting(string name, System.Security.AccessControl.EventWaitHandleRights rights) { return default(System.Threading.EventWaitHandle); }
+    public bool Reset() { return default(bool); }
+    public bool Set() { return default(bool); }
+    public static bool TryOpenExisting(string name, System.Security.AccessControl.EventWaitHandleRights rights, out System.Threading.EventWaitHandle result) { result = default(System.Threading.EventWaitHandle); return default(bool); }
+    public static bool TryOpenExisting(string name, out System.Threading.EventWaitHandle result) { result = default(System.Threading.EventWaitHandle); return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ManualResetEvent : System.Threading.EventWaitHandle {
+    public ManualResetEvent(bool initialState) : base (default(bool), default(System.Threading.EventResetMode)) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Mutex : System.Threading.WaitHandle {
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public Mutex() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public Mutex(bool initiallyOwned) { }
+    public Mutex(bool initiallyOwned, string name) { }
+    public Mutex(bool initiallyOwned, string name, out bool createdNew) { createdNew = default(bool); }
+    public Mutex(bool initiallyOwned, string name, out bool createdNew, System.Security.AccessControl.MutexSecurity mutexSecurity) { createdNew = default(bool); }
+    public static System.Threading.Mutex OpenExisting(string name) { return default(System.Threading.Mutex); }
+    public static System.Threading.Mutex OpenExisting(string name, System.Security.AccessControl.MutexRights rights) { return default(System.Threading.Mutex); }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public void ReleaseMutex() { }
+    public static bool TryOpenExisting(string name, System.Security.AccessControl.MutexRights rights, out System.Threading.Mutex result) { result = default(System.Threading.Mutex); return default(bool); }
+    public static bool TryOpenExisting(string name, out System.Threading.Mutex result) { result = default(System.Threading.Mutex); return default(bool); }
+  }
+
+} // end of System.Threading

fxdac/fxdac/Data/Contracts/System.Threading.Semaphore.cs

@@ -0,0 +1,99 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Security.AccessControl {
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public sealed partial class SemaphoreAccessRule : System.Security.AccessControl.AccessRule {
+    public SemaphoreAccessRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.SemaphoreRights semaphoreRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public SemaphoreAccessRule(string identity, System.Security.AccessControl.SemaphoreRights semaphoreRights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType)) { }
+    public System.Security.AccessControl.SemaphoreRights SemaphoreRights { get { return default(System.Security.AccessControl.SemaphoreRights); } }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public sealed partial class SemaphoreAuditRule : System.Security.AccessControl.AuditRule {
+    public SemaphoreAuditRule(System.Security.Principal.IdentityReference identity, System.Security.AccessControl.SemaphoreRights semaphoreRights, System.Security.AccessControl.AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags)) { }
+    public System.Security.AccessControl.SemaphoreRights SemaphoreRights { get { return default(System.Security.AccessControl.SemaphoreRights); } }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public enum SemaphoreRights {
+    ChangePermissions = 262144,
+    Delete = 65536,
+    FullControl = 2031619,
+    Modify = 2,
+    ReadPermissions = 131072,
+    Synchronize = 1048576,
+    TakeOwnership = 524288,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public sealed partial class SemaphoreSecurity : System.Security.AccessControl.NativeObjectSecurity {
+    public SemaphoreSecurity() : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public SemaphoreSecurity(string name, System.Security.AccessControl.AccessControlSections includeSections) : base (default(bool), default(System.Security.AccessControl.ResourceType)) { }
+    public override System.Type AccessRightType { get { return default(System.Type); } }
+    public override System.Type AccessRuleType { get { return default(System.Type); } }
+    public override System.Type AuditRuleType { get { return default(System.Type); } }
+    public override System.Security.AccessControl.AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AccessControlType type) { return default(System.Security.AccessControl.AccessRule); }
+    public void AddAccessRule(System.Security.AccessControl.SemaphoreAccessRule rule) { }
+    public void AddAuditRule(System.Security.AccessControl.SemaphoreAuditRule rule) { }
+    public override System.Security.AccessControl.AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, System.Security.AccessControl.InheritanceFlags inheritanceFlags, System.Security.AccessControl.PropagationFlags propagationFlags, System.Security.AccessControl.AuditFlags flags) { return default(System.Security.AccessControl.AuditRule); }
+    public bool RemoveAccessRule(System.Security.AccessControl.SemaphoreAccessRule rule) { return default(bool); }
+    public void RemoveAccessRuleAll(System.Security.AccessControl.SemaphoreAccessRule rule) { }
+    public void RemoveAccessRuleSpecific(System.Security.AccessControl.SemaphoreAccessRule rule) { }
+    public bool RemoveAuditRule(System.Security.AccessControl.SemaphoreAuditRule rule) { return default(bool); }
+    public void RemoveAuditRuleAll(System.Security.AccessControl.SemaphoreAuditRule rule) { }
+    public void RemoveAuditRuleSpecific(System.Security.AccessControl.SemaphoreAuditRule rule) { }
+    public void ResetAccessRule(System.Security.AccessControl.SemaphoreAccessRule rule) { }
+    public void SetAccessRule(System.Security.AccessControl.SemaphoreAccessRule rule) { }
+    public void SetAuditRule(System.Security.AccessControl.SemaphoreAuditRule rule) { }
+  }
+
+} // end of System.Security.AccessControl
+namespace System.Security.Permissions {
+  public sealed partial class TypeDescriptorPermission : System.Security.CodeAccessPermission, System.Security.Permissions.IUnrestrictedPermission {
+    public TypeDescriptorPermission(System.Security.Permissions.PermissionState state) { }
+    public TypeDescriptorPermission(System.Security.Permissions.TypeDescriptorPermissionFlags flag) { }
+    public System.Security.Permissions.TypeDescriptorPermissionFlags Flags { get { return default(System.Security.Permissions.TypeDescriptorPermissionFlags); } set { } }
+    public override System.Security.IPermission Copy() { return default(System.Security.IPermission); }
+    public override void FromXml(System.Security.SecurityElement securityElement) { }
+    public override System.Security.IPermission Intersect(System.Security.IPermission target) { return default(System.Security.IPermission); }
+    public override bool IsSubsetOf(System.Security.IPermission target) { return default(bool); }
+    public bool IsUnrestricted() { return default(bool); }
+    public override System.Security.SecurityElement ToXml() { return default(System.Security.SecurityElement); }
+    public override System.Security.IPermission Union(System.Security.IPermission target) { return default(System.Security.IPermission); }
+  }
+
+  [System.FlagsAttribute]
+  public enum TypeDescriptorPermissionFlags {
+    NoFlags = 0,
+    RestrictedRegistrationAccess = 1,
+  }
+
+} // end of System.Security.Permissions
+namespace System.Threading {
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public sealed partial class Semaphore : System.Threading.WaitHandle {
+    public Semaphore(int initialCount, int maximumCount) { }
+    public Semaphore(int initialCount, int maximumCount, string name) { }
+    public Semaphore(int initialCount, int maximumCount, string name, out bool createdNew) { createdNew = default(bool); }
+    public Semaphore(int initialCount, int maximumCount, string name, out bool createdNew, System.Security.AccessControl.SemaphoreSecurity semaphoreSecurity) { createdNew = default(bool); }
+    public System.Security.AccessControl.SemaphoreSecurity GetAccessControl() { return default(System.Security.AccessControl.SemaphoreSecurity); }
+    public static System.Threading.Semaphore OpenExisting(string name) { return default(System.Threading.Semaphore); }
+    public static System.Threading.Semaphore OpenExisting(string name, System.Security.AccessControl.SemaphoreRights rights) { return default(System.Threading.Semaphore); }
+    [System.Runtime.ConstrainedExecution.PrePrepareMethodAttribute]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public int Release() { return default(int); }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public int Release(int releaseCount) { return default(int); }
+    public void SetAccessControl(System.Security.AccessControl.SemaphoreSecurity semaphoreSecurity) { }
+    public static bool TryOpenExisting(string name, System.Security.AccessControl.SemaphoreRights rights, out System.Threading.Semaphore result) { result = default(System.Threading.Semaphore); return default(bool); }
+    public static bool TryOpenExisting(string name, out System.Threading.Semaphore result) { result = default(System.Threading.Semaphore); return default(bool); }
+  }
+
+  public partial class ThreadExceptionEventArgs : System.EventArgs {
+    public ThreadExceptionEventArgs(System.Exception t) { }
+    public System.Exception Exception { get { return default(System.Exception); } }
+  }
+
+  public delegate void ThreadExceptionEventHandler(object sender, System.Threading.ThreadExceptionEventArgs e);
+
+} // end of System.Threading

fxdac/fxdac/Data/Contracts/System.Threading.Tasks.Parallel.cs

@@ -0,0 +1,64 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Threading.Tasks {
+  public static partial class Parallel {
+    public static System.Threading.Tasks.ParallelLoopResult For(int fromInclusive, int toExclusive, System.Action<int, System.Threading.Tasks.ParallelLoopState> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For(int fromInclusive, int toExclusive, System.Action<int> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For(int fromInclusive, int toExclusive, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<int, System.Threading.Tasks.ParallelLoopState> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For(int fromInclusive, int toExclusive, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<int> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For(long fromInclusive, long toExclusive, System.Action<long, System.Threading.Tasks.ParallelLoopState> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For(long fromInclusive, long toExclusive, System.Action<long> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For(long fromInclusive, long toExclusive, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<long, System.Threading.Tasks.ParallelLoopState> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For(long fromInclusive, long toExclusive, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<long> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive, System.Func<TLocal> localInit, System.Func<int, System.Threading.Tasks.ParallelLoopState, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive, System.Threading.Tasks.ParallelOptions parallelOptions, System.Func<TLocal> localInit, System.Func<int, System.Threading.Tasks.ParallelLoopState, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For<TLocal>(long fromInclusive, long toExclusive, System.Func<TLocal> localInit, System.Func<long, System.Threading.Tasks.ParallelLoopState, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult For<TLocal>(long fromInclusive, long toExclusive, System.Threading.Tasks.ParallelOptions parallelOptions, System.Func<TLocal> localInit, System.Func<long, System.Threading.Tasks.ParallelLoopState, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.OrderablePartitioner<TSource> source, System.Action<TSource, System.Threading.Tasks.ParallelLoopState, long> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.OrderablePartitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<TSource, System.Threading.Tasks.ParallelLoopState, long> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.Partitioner<TSource> source, System.Action<TSource, System.Threading.Tasks.ParallelLoopState> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.Partitioner<TSource> source, System.Action<TSource> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.Partitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<TSource, System.Threading.Tasks.ParallelLoopState> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.Partitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<TSource> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Action<TSource, System.Threading.Tasks.ParallelLoopState, long> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Action<TSource, System.Threading.Tasks.ParallelLoopState> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Action<TSource> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<TSource, System.Threading.Tasks.ParallelLoopState, long> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<TSource, System.Threading.Tasks.ParallelLoopState> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Action<TSource> body) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource, TLocal>(System.Collections.Concurrent.OrderablePartitioner<TSource> source, System.Func<TLocal> localInit, System.Func<TSource, System.Threading.Tasks.ParallelLoopState, long, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource, TLocal>(System.Collections.Concurrent.OrderablePartitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Func<TLocal> localInit, System.Func<TSource, System.Threading.Tasks.ParallelLoopState, long, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource, TLocal>(System.Collections.Concurrent.Partitioner<TSource> source, System.Func<TLocal> localInit, System.Func<TSource, System.Threading.Tasks.ParallelLoopState, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource, TLocal>(System.Collections.Concurrent.Partitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Func<TLocal> localInit, System.Func<TSource, System.Threading.Tasks.ParallelLoopState, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource, TLocal>(System.Collections.Generic.IEnumerable<TSource> source, System.Func<TLocal> localInit, System.Func<TSource, System.Threading.Tasks.ParallelLoopState, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource, TLocal>(System.Collections.Generic.IEnumerable<TSource> source, System.Func<TLocal> localInit, System.Func<TSource, System.Threading.Tasks.ParallelLoopState, long, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource, TLocal>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Func<TLocal> localInit, System.Func<TSource, System.Threading.Tasks.ParallelLoopState, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource, TLocal>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, System.Func<TLocal> localInit, System.Func<TSource, System.Threading.Tasks.ParallelLoopState, long, TLocal, TLocal> body, System.Action<TLocal> localFinally) { return default(System.Threading.Tasks.ParallelLoopResult); }
+    public static void Invoke(params System.Action[] actions) { }
+    public static void Invoke(System.Threading.Tasks.ParallelOptions parallelOptions, params System.Action[] actions) { }
+  }
+
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct ParallelLoopResult {
+    public bool IsCompleted { get { return default(bool); } }
+    public System.Nullable<long> LowestBreakIteration { get { return default(System.Nullable<long>); } }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("ShouldExitCurrentIteration = {ShouldExitCurrentIteration}")]
+  public partial class ParallelLoopState {
+    internal ParallelLoopState() { }
+    public bool IsExceptional { get { return default(bool); } }
+    public bool IsStopped { get { return default(bool); } }
+    public System.Nullable<long> LowestBreakIteration { get { return default(System.Nullable<long>); } }
+    public bool ShouldExitCurrentIteration { get { return default(bool); } }
+    public void Break() { }
+    public void Stop() { }
+  }
+
+  public partial class ParallelOptions {
+    public ParallelOptions() { }
+    public System.Threading.CancellationToken CancellationToken { get { return default(System.Threading.CancellationToken); } set { } }
+    public int MaxDegreeOfParallelism { get { return default(int); } set { } }
+    public System.Threading.Tasks.TaskScheduler TaskScheduler { get { return default(System.Threading.Tasks.TaskScheduler); } set { } }
+  }
+
+} // end of System.Threading.Tasks

fxdac/fxdac/Data/Contracts/System.Threading.Tasks.cs

@@ -0,0 +1,28 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Threading {
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class CancellationTokenSource : System.IDisposable {
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    public CancellationTokenSource() { }
+    public CancellationTokenSource(int millisecondsDelay) { }
+    public CancellationTokenSource(System.TimeSpan delay) { }
+    public bool IsCancellationRequested { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(bool); } }
+    public System.Threading.CancellationToken Token { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(System.Threading.CancellationToken); } }
+    public void Cancel() { }
+    public void Cancel(bool throwOnFirstException) { }
+    public void CancelAfter(int millisecondsDelay) { }
+    public void CancelAfter(System.TimeSpan delay) { }
+    public static System.Threading.CancellationTokenSource CreateLinkedTokenSource(System.Threading.CancellationToken token1, System.Threading.CancellationToken token2) { return default(System.Threading.CancellationTokenSource); }
+    public static System.Threading.CancellationTokenSource CreateLinkedTokenSource(params System.Threading.CancellationToken[] tokens) { return default(System.Threading.CancellationTokenSource); }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+  }
+
+} // end of System.Threading
+namespace System.Threading.Tasks {
+  public static partial class TaskExtensions {
+    public static System.Threading.Tasks.Task Unwrap(this System.Threading.Tasks.Task<System.Threading.Tasks.Task> task) { return default(System.Threading.Tasks.Task); }
+    public static System.Threading.Tasks.Task<TResult> Unwrap<TResult>(this System.Threading.Tasks.Task<System.Threading.Tasks.Task<TResult>> task) { return default(System.Threading.Tasks.Task<TResult>); }
+  }
+
+} // end of System.Threading.Tasks

fxdac/fxdac/Data/Contracts/System.Threading.Thread.cs

@@ -0,0 +1,155 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Threading {
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public delegate void ParameterizedThreadStart(object obj);
+
+  [System.Runtime.InteropServices.ClassInterfaceAttribute((System.Runtime.InteropServices.ClassInterfaceType)(0))]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Thread : System.Runtime.ConstrainedExecution.CriticalFinalizerObject {
+    [System.Security.SecuritySafeCriticalAttribute]
+    public Thread(System.Threading.ParameterizedThreadStart start) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public Thread(System.Threading.ParameterizedThreadStart start, int maxStackSize) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public Thread(System.Threading.ThreadStart start) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public Thread(System.Threading.ThreadStart start, int maxStackSize) { }
+    [System.ObsoleteAttribute("Deprecated in favor of GetApartmentState, SetApartmentState and TrySetApartmentState.")]
+    public System.Threading.ApartmentState ApartmentState { get { return default(System.Threading.ApartmentState); } set { } }
+    public System.Globalization.CultureInfo CurrentCulture { get { return default(System.Globalization.CultureInfo); } set { } }
+    public static System.Security.Principal.IPrincipal CurrentPrincipal { get { return default(System.Security.Principal.IPrincipal); } set { } }
+    public static System.Threading.Thread CurrentThread { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]get { return default(System.Threading.Thread); } }
+    public System.Globalization.CultureInfo CurrentUICulture { get { return default(System.Globalization.CultureInfo); } set { } }
+    public System.Threading.ExecutionContext ExecutionContext { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1)), System.Security.SecuritySafeCriticalAttribute]get { return default(System.Threading.ExecutionContext); } }
+    public bool IsAlive { get { return default(bool); } }
+    public bool IsBackground { get { return default(bool); } set { } }
+    public bool IsThreadPoolThread { get { return default(bool); } }
+    public int ManagedThreadId { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]get { return default(int); } }
+    public string Name { get { return default(string); } set { } }
+    public System.Threading.ThreadPriority Priority { [System.Security.SecuritySafeCriticalAttribute]get { return default(System.Threading.ThreadPriority); } [System.Security.SecuritySafeCriticalAttribute]set { } }
+    public System.Threading.ThreadState ThreadState { get { return default(System.Threading.ThreadState); } }
+    public void Abort() { }
+    public void Abort(object stateInfo) { }
+    public static System.LocalDataStoreSlot AllocateDataSlot() { return default(System.LocalDataStoreSlot); }
+    public static System.LocalDataStoreSlot AllocateNamedDataSlot(string name) { return default(System.LocalDataStoreSlot); }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void BeginCriticalRegion() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void BeginThreadAffinity() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void EndCriticalRegion() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    public static void EndThreadAffinity() { }
+    ~Thread() { }
+    public static void FreeNamedDataSlot(string name) { }
+    public System.Threading.ApartmentState GetApartmentState() { return default(System.Threading.ApartmentState); }
+    [System.ObsoleteAttribute("Thread.GetCompressedStack is no longer supported. Please use the System.Threading.CompressedStack class")]
+    [System.Security.SecurityCriticalAttribute]
+    public System.Threading.CompressedStack GetCompressedStack() { return default(System.Threading.CompressedStack); }
+    public static object GetData(System.LocalDataStoreSlot slot) { return default(object); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static int GetDomainID() { return default(int); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public override int GetHashCode() { return default(int); }
+    public static System.LocalDataStoreSlot GetNamedDataSlot(string name) { return default(System.LocalDataStoreSlot); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Interrupt() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Join() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public bool Join(int millisecondsTimeout) { return default(bool); }
+    public bool Join(System.TimeSpan timeout) { return default(bool); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
+    public static void MemoryBarrier() { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static void ResetAbort() { }
+    [System.ObsoleteAttribute("Thread.Resume has been deprecated.  Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources.  http://go.microsoft.com/fwlink/?linkid=14202", false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Resume() { }
+    public void SetApartmentState(System.Threading.ApartmentState state) { }
+    [System.ObsoleteAttribute("Thread.SetCompressedStack is no longer supported. Please use the System.Threading.CompressedStack class")]
+    [System.Security.SecurityCriticalAttribute]
+    public void SetCompressedStack(System.Threading.CompressedStack stack) { }
+    public static void SetData(System.LocalDataStoreSlot slot, object data) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static void Sleep(int millisecondsTimeout) { }
+    public static void Sleep(System.TimeSpan timeout) { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void SpinWait(int iterations) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]    public void Start() { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]    public void Start(object parameter) { }
+    [System.ObsoleteAttribute("Thread.Suspend has been deprecated.  Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources.  http://go.microsoft.com/fwlink/?linkid=14202", false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Suspend() { }
+    public bool TrySetApartmentState(System.Threading.ApartmentState state) { return default(bool); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static byte VolatileRead(ref byte address) { return default(byte); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static double VolatileRead(ref double address) { return default(double); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static short VolatileRead(ref short address) { return default(short); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static int VolatileRead(ref int address) { return default(int); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static long VolatileRead(ref long address) { return default(long); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static System.IntPtr VolatileRead(ref System.IntPtr address) { return default(System.IntPtr); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static object VolatileRead(ref object address) { return default(object); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static sbyte VolatileRead(ref sbyte address) { return default(sbyte); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static float VolatileRead(ref float address) { return default(float); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static ushort VolatileRead(ref ushort address) { return default(ushort); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static uint VolatileRead(ref uint address) { return default(uint); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static ulong VolatileRead(ref ulong address) { return default(ulong); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static System.UIntPtr VolatileRead(ref System.UIntPtr address) { return default(System.UIntPtr); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void VolatileWrite(ref byte address, byte value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void VolatileWrite(ref double address, double value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void VolatileWrite(ref short address, short value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void VolatileWrite(ref int address, int value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void VolatileWrite(ref long address, long value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void VolatileWrite(ref System.IntPtr address, System.IntPtr value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void VolatileWrite(ref object address, object value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static void VolatileWrite(ref sbyte address, sbyte value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void VolatileWrite(ref float address, float value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static void VolatileWrite(ref ushort address, ushort value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static void VolatileWrite(ref uint address, uint value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static void VolatileWrite(ref ulong address, ulong value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    public static void VolatileWrite(ref System.UIntPtr address, System.UIntPtr value) { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static bool Yield() { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public delegate void ThreadStart();
+
+  public sealed partial class ThreadStartException : System.SystemException {
+    internal ThreadStartException() { }
+  }
+
+  [System.FlagsAttribute]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum ThreadState {
+    Aborted = 256,
+    AbortRequested = 128,
+    Background = 4,
+    Running = 0,
+    Stopped = 16,
+    StopRequested = 1,
+    Suspended = 64,
+    SuspendRequested = 2,
+    Unstarted = 8,
+    WaitSleepJoin = 32,
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ThreadStateException : System.SystemException {
+    public ThreadStateException() { }
+    protected ThreadStateException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public ThreadStateException(string message) { }
+    public ThreadStateException(string message, System.Exception innerException) { }
+  }
+
+} // end of System.Threading

fxdac/fxdac/Data/Contracts/System.Threading.ThreadPool.cs

@@ -0,0 +1,61 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Threading {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class RegisteredWaitHandle {
+    internal RegisteredWaitHandle() { }
+    [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+    public bool Unregister(System.Threading.WaitHandle waitObject) { return default(bool); }
+  }
+
+  public static partial class ThreadPool {
+    [System.ObsoleteAttribute("ThreadPool.BindHandle(IntPtr) has been deprecated.  Please use ThreadPool.BindHandle(SafeHandle) instead.", false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static bool BindHandle(System.IntPtr osHandle) { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static bool BindHandle(System.Runtime.InteropServices.SafeHandle osHandle) { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static void GetAvailableThreads(out int workerThreads, out int completionPortThreads) { workerThreads = default(int); completionPortThreads = default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static void GetMaxThreads(out int workerThreads, out int completionPortThreads) { workerThreads = default(int); completionPortThreads = default(int); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static void GetMinThreads(out int workerThreads, out int completionPortThreads) { workerThreads = default(int); completionPortThreads = default(int); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecuritySafeCriticalAttribute]
+    public static bool QueueUserWorkItem(System.Threading.WaitCallback callBack) { return default(bool); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecuritySafeCriticalAttribute]
+    public static bool QueueUserWorkItem(System.Threading.WaitCallback callBack, object state) { return default(bool); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecuritySafeCriticalAttribute]
+    public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, int millisecondsTimeOutInterval, bool executeOnlyOnce) { return default(System.Threading.RegisteredWaitHandle); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecuritySafeCriticalAttribute]
+    public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce) { return default(System.Threading.RegisteredWaitHandle); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecuritySafeCriticalAttribute]
+    public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, System.TimeSpan timeout, bool executeOnlyOnce) { return default(System.Threading.RegisteredWaitHandle); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.CLSCompliantAttribute(false)]
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce) { return default(System.Threading.RegisteredWaitHandle); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static bool SetMaxThreads(int workerThreads, int completionPortThreads) { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static bool SetMinThreads(int workerThreads, int completionPortThreads) { return default(bool); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public unsafe static bool UnsafeQueueNativeOverlapped(System.Threading.NativeOverlapped* overlapped) { return default(bool); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecurityCriticalAttribute]
+    public static bool UnsafeQueueUserWorkItem(System.Threading.WaitCallback callBack, object state) { return default(bool); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecurityCriticalAttribute]
+    public static System.Threading.RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, int millisecondsTimeOutInterval, bool executeOnlyOnce) { return default(System.Threading.RegisteredWaitHandle); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecurityCriticalAttribute]
+    public static System.Threading.RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce) { return default(System.Threading.RegisteredWaitHandle); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecurityCriticalAttribute]
+    public static System.Threading.RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, System.TimeSpan timeout, bool executeOnlyOnce) { return default(System.Threading.RegisteredWaitHandle); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.CLSCompliantAttribute(false)]
+    [System.Security.SecurityCriticalAttribute]
+    public static System.Threading.RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce) { return default(System.Threading.RegisteredWaitHandle); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public delegate void WaitCallback(object state);
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public delegate void WaitOrTimerCallback(object state, bool timedOut);
+
+} // end of System.Threading

fxdac/fxdac/Data/Contracts/System.Threading.Timer.cs

@@ -0,0 +1,23 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Threading {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class Timer :System.IDisposable {
+    public Timer(System.Threading.TimerCallback callback) { }
+    public Timer(System.Threading.TimerCallback callback, object state, int dueTime, int period) { }
+    public Timer(System.Threading.TimerCallback callback, object state, long dueTime, long period) { }
+    public Timer(System.Threading.TimerCallback callback, object state, System.TimeSpan dueTime, System.TimeSpan period) { }
+    [System.CLSCompliantAttribute(false)]
+    public Timer(System.Threading.TimerCallback callback, object state, uint dueTime, uint period) { }
+    public bool Change(int dueTime, int period) { return default(bool); }
+    public bool Change(long dueTime, long period) { return default(bool); }
+    public bool Change(System.TimeSpan dueTime, System.TimeSpan period) { return default(bool); }
+    [System.CLSCompliantAttribute(false)]
+    public bool Change(uint dueTime, uint period) { return default(bool); }
+    public void Dispose() { }
+    public bool Dispose(System.Threading.WaitHandle notifyObject) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public delegate void TimerCallback(object state);
+
+} // end of System.Threading

fxdac/fxdac/Data/Contracts/System.Threading.cs

@@ -0,0 +1,516 @@
+[assembly:System.CLSCompliant(true)]
+namespace System {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class LocalDataStoreSlot {
+    internal LocalDataStoreSlot() { }
+    ~LocalDataStoreSlot() { }
+  }
+
+} // end of System
+namespace System.Runtime.InteropServices {
+  [System.CLSCompliantAttribute(false)]
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.GuidAttribute("C281C7F1-4AA9-3517-961A-463CFED57E75")]
+  [System.Runtime.InteropServices.InterfaceTypeAttribute((System.Runtime.InteropServices.ComInterfaceType)(1))]
+  public partial interface _Thread {
+    void GetIDsOfNames(ref System.Guid riid, System.IntPtr rgszNames, uint cNames, uint lcid, System.IntPtr rgDispId);
+    void GetTypeInfo(uint iTInfo, uint lcid, System.IntPtr ppTInfo);
+    void GetTypeInfoCount(out uint pcTInfo);
+    void Invoke(uint dispIdMember, ref System.Guid riid, uint lcid, short wFlags, System.IntPtr pDispParams, System.IntPtr pVarResult, System.IntPtr pExcepInfo, System.IntPtr puArgErr);
+  }
+
+} // end of System.Runtime.InteropServices
+namespace System.Threading {
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum ApartmentState {
+    MTA = 1,
+    STA = 0,
+    Unknown = 2,
+  }
+
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct AsyncFlowControl : System.IDisposable {
+    public void Dispose() { }
+    public override bool Equals(object obj) { return default(bool); }
+    public bool Equals(System.Threading.AsyncFlowControl obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public static bool operator ==(System.Threading.AsyncFlowControl a, System.Threading.AsyncFlowControl b) { return default(bool); }
+    public static bool operator !=(System.Threading.AsyncFlowControl a, System.Threading.AsyncFlowControl b) { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public void Undo() { }
+  }
+
+  public sealed partial class CompressedStack : System.Runtime.Serialization.ISerializable {
+    internal CompressedStack() { }
+    public static System.Threading.CompressedStack Capture() { return default(System.Threading.CompressedStack); }
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public System.Threading.CompressedStack CreateCopy() { return default(System.Threading.CompressedStack); }
+    [System.Security.SecurityCriticalAttribute]
+    public static System.Threading.CompressedStack GetCompressedStack() { return default(System.Threading.CompressedStack); }
+    [System.Security.SecurityCriticalAttribute]
+    public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    [System.Security.SecurityCriticalAttribute]
+    public static void Run(System.Threading.CompressedStack compressedStack, System.Threading.ContextCallback callback, object state) { }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Initial Count={InitialCount}, Current Count={CurrentCount}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class CountdownEvent : System.IDisposable {
+    public CountdownEvent(int initialCount) { }
+    public int CurrentCount { get { return default(int); } }
+    public int InitialCount { get { return default(int); } }
+    public bool IsSet { get { return default(bool); } }
+    public System.Threading.WaitHandle WaitHandle { get { return default(System.Threading.WaitHandle); } }
+    public void AddCount() { }
+    public void AddCount(int signalCount) { }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public void Reset() { }
+    public void Reset(int count) { }
+    public bool Signal() { return default(bool); }
+    public bool Signal(int signalCount) { return default(bool); }
+    public bool TryAddCount() { return default(bool); }
+    public bool TryAddCount(int signalCount) { return default(bool); }
+    public void Wait() { }
+    public bool Wait(int millisecondsTimeout) { return default(bool); }
+    public bool Wait(int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+    public void Wait(System.Threading.CancellationToken cancellationToken) { }
+    public bool Wait(System.TimeSpan timeout) { return default(bool); }
+    public bool Wait(System.TimeSpan timeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public enum EventResetMode {
+    AutoReset = 0,
+    ManualReset = 1,
+  }
+
+  public sealed partial class ExecutionContext : System.IDisposable, System.Runtime.Serialization.ISerializable {
+    internal ExecutionContext() { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)][System.Security.SecuritySafeCriticalAttribute]
+    public static System.Threading.ExecutionContext Capture() { return default(System.Threading.ExecutionContext); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public System.Threading.ExecutionContext CreateCopy() { return default(System.Threading.ExecutionContext); }
+    public void Dispose() { }
+    [System.Security.SecurityCriticalAttribute]
+    public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public static bool IsFlowSuppressed() { return default(bool); }
+    [System.Security.SecuritySafeCriticalAttribute]
+    public static void RestoreFlow() { }
+    [System.Security.SecurityCriticalAttribute]
+    public static void Run(System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, object state) { }
+    [System.Security.SecurityCriticalAttribute]
+    public static System.Threading.AsyncFlowControl SuppressFlow() { return default(System.Threading.AsyncFlowControl); }
+  }
+
+  public static partial class Interlocked {
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static int Add(ref int location1, int value) { return default(int); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static long Add(ref long location1, long value) { return default(long); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static double CompareExchange(ref double location1, double value, double comparand) { return default(double); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static int CompareExchange(ref int location1, int value, int comparand) { return default(int); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static long CompareExchange(ref long location1, long value, long comparand) { return default(long); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static System.IntPtr CompareExchange(ref System.IntPtr location1, System.IntPtr value, System.IntPtr comparand) { return default(System.IntPtr); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static object CompareExchange(ref object location1, object value, object comparand) { return default(object); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static float CompareExchange(ref float location1, float value, float comparand) { return default(float); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class { return default(T); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static int Decrement(ref int location) { return default(int); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static long Decrement(ref long location) { return default(long); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static double Exchange(ref double location1, double value) { return default(double); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static int Exchange(ref int location1, int value) { return default(int); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static long Exchange(ref long location1, long value) { return default(long); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static System.IntPtr Exchange(ref System.IntPtr location1, System.IntPtr value) { return default(System.IntPtr); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static object Exchange(ref object location1, object value) { return default(object); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static float Exchange(ref float location1, float value) { return default(float); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+    public static T Exchange<T>(ref T location1, T value) where T : class { return default(T); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static int Increment(ref int location) { return default(int); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static long Increment(ref long location) { return default(long); }
+    public static void MemoryBarrier() { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static long Read(ref long location) { return default(long); }
+  }
+
+  public static partial class LazyInitializer {
+    public static T EnsureInitialized<T>(ref T target) where T : class { return default(T); }
+    public static T EnsureInitialized<T>(ref T target, ref bool initialized, ref object syncLock) { return default(T); }
+    public static T EnsureInitialized<T>(ref T target, ref bool initialized, ref object syncLock, System.Func<T> valueFactory) { return default(T); }
+    public static T EnsureInitialized<T>(ref T target, System.Func<T> valueFactory) where T : class { return default(T); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct LockCookie {
+    public override bool Equals(object obj) { return default(bool); }
+    public bool Equals(System.Threading.LockCookie obj) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public static bool operator ==(System.Threading.LockCookie a, System.Threading.LockCookie b) { return default(bool); }
+    public static bool operator !=(System.Threading.LockCookie a, System.Threading.LockCookie b) { return default(bool); }
+  }
+
+  public partial class LockRecursionException : System.Exception {
+    public LockRecursionException() { }
+    protected LockRecursionException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public LockRecursionException(string message) { }
+    public LockRecursionException(string message, System.Exception innerException) { }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Set = {IsSet}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class ManualResetEventSlim : System.IDisposable {
+    public ManualResetEventSlim() { }
+    public ManualResetEventSlim(bool initialState) { }
+    public ManualResetEventSlim(bool initialState, int spinCount) { }
+    public bool IsSet { get { return default(bool); } }
+    public int SpinCount { get { return default(int); } }
+    public System.Threading.WaitHandle WaitHandle { get { return default(System.Threading.WaitHandle); } }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public void Reset() { }
+    public void Set() { }
+    public void Wait() { }
+    public bool Wait(int millisecondsTimeout) { return default(bool); }
+    public bool Wait(int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+    public void Wait(System.Threading.CancellationToken cancellationToken) { }
+    public bool Wait(System.TimeSpan timeout) { return default(bool); }
+    public bool Wait(System.TimeSpan timeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public static partial class Monitor {
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]public static void Enter(object obj) { }
+    public static void Enter(object obj, ref bool lockTaken) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Exit(object obj) { }
+    public static bool IsEntered(object obj) { return default(bool); }
+    public static void Pulse(object obj) { }
+    public static void PulseAll(object obj) { }
+    public static bool TryEnter(object obj) { return default(bool); }
+    public static void TryEnter(object obj, ref bool lockTaken) { }
+    public static bool TryEnter(object obj, int millisecondsTimeout) { return default(bool); }
+    public static void TryEnter(object obj, int millisecondsTimeout, ref bool lockTaken) { }
+    public static bool TryEnter(object obj, System.TimeSpan timeout) { return default(bool); }
+    public static void TryEnter(object obj, System.TimeSpan timeout, ref bool lockTaken) { }
+    public static bool Wait(object obj) { return default(bool); }
+    public static bool Wait(object obj, int millisecondsTimeout) { return default(bool); }
+    public static bool Wait(object obj, int millisecondsTimeout, bool exitContext) { return default(bool); }
+    public static bool Wait(object obj, System.TimeSpan timeout) { return default(bool); }
+    public static bool Wait(object obj, System.TimeSpan timeout, bool exitContext) { return default(bool); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ReaderWriterLock : System.Runtime.ConstrainedExecution.CriticalFinalizerObject {
+    public ReaderWriterLock() { }
+    public bool IsReaderLockHeld { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]get { return default(bool); } }
+    public bool IsWriterLockHeld { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]get { return default(bool); } }
+    public int WriterSeqNum { get { return default(int); } }
+    public void AcquireReaderLock(int millisecondsTimeout) { }
+    public void AcquireReaderLock(System.TimeSpan timeout) { }
+    public void AcquireWriterLock(int millisecondsTimeout) { }
+    public void AcquireWriterLock(System.TimeSpan timeout) { }
+    public bool AnyWritersSince(int seqNum) { return default(bool); }
+    public void DowngradeFromWriterLock(ref System.Threading.LockCookie lockCookie) { }
+    ~ReaderWriterLock() { }
+    public System.Threading.LockCookie ReleaseLock() { return default(System.Threading.LockCookie); }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public void ReleaseReaderLock() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public void ReleaseWriterLock() { }
+    public void RestoreLock(ref System.Threading.LockCookie lockCookie) { }
+    public System.Threading.LockCookie UpgradeToWriterLock(int millisecondsTimeout) { return default(System.Threading.LockCookie); }
+    public System.Threading.LockCookie UpgradeToWriterLock(System.TimeSpan timeout) { return default(System.Threading.LockCookie); }
+  }
+
+  [System.Runtime.CompilerServices.TypeForwardedFromAttribute("System, Version=2.0.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class SemaphoreFullException : System.SystemException {
+    public SemaphoreFullException() { }
+    protected SemaphoreFullException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public SemaphoreFullException(string message) { }
+    public SemaphoreFullException(string message, System.Exception innerException) { }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Current Count = {m_currentCount}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class SemaphoreSlim : System.IDisposable {
+    public SemaphoreSlim(int initialCount) { }
+    public SemaphoreSlim(int initialCount, int maxCount) { }
+    public System.Threading.WaitHandle AvailableWaitHandle { get { return default(System.Threading.WaitHandle); } }
+    public int CurrentCount { get { return default(int); } }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public int Release() { return default(int); }
+    public int Release(int releaseCount) { return default(int); }
+    public void Wait() { }
+    public bool Wait(int millisecondsTimeout) { return default(bool); }
+    public bool Wait(int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+    public void Wait(System.Threading.CancellationToken cancellationToken) { }
+    public bool Wait(System.TimeSpan timeout) { return default(bool); }
+    public bool Wait(System.TimeSpan timeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+    public System.Threading.Tasks.Task WaitAsync() { return default(System.Threading.Tasks.Task); }
+    public System.Threading.Tasks.Task<bool> WaitAsync(int millisecondsTimeout) { return default(System.Threading.Tasks.Task<bool>); }
+    public System.Threading.Tasks.Task<bool> WaitAsync(int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<bool>); }
+    public System.Threading.Tasks.Task WaitAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
+    public System.Threading.Tasks.Task<bool> WaitAsync(System.TimeSpan timeout) { return default(System.Threading.Tasks.Task<bool>); }
+    public System.Threading.Tasks.Task<bool> WaitAsync(System.TimeSpan timeout, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<bool>); }
+  }
+
+  public delegate void SendOrPostCallback(object state);
+
+  [System.Diagnostics.DebuggerDisplayAttribute("IsHeld = {IsHeld}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct SpinLock {
+    public SpinLock(bool enableThreadOwnerTracking) { throw new System.NotImplementedException(); }
+    public bool IsHeld { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]get { return default(bool); } }
+    public bool IsHeldByCurrentThread { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]get { return default(bool); } }
+    public bool IsThreadOwnerTrackingEnabled { [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]get { return default(bool); } }
+    public void Enter(ref bool lockTaken) { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public void Exit() { }
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public void Exit(bool useMemoryBarrier) { }
+    public void TryEnter(ref bool lockTaken) { }
+    public void TryEnter(int millisecondsTimeout, ref bool lockTaken) { }
+    public void TryEnter(System.TimeSpan timeout, ref bool lockTaken) { }
+  }
+
+  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+  public partial struct SpinWait {
+    public int Count { get { return default(int); } }
+    public bool NextSpinWillYield { get { return default(bool); } }
+    public void Reset() { }
+    public void SpinOnce() { }
+    public static void SpinUntil(System.Func<bool> condition) { }
+    public static bool SpinUntil(System.Func<bool> condition, int millisecondsTimeout) { return default(bool); }
+    public static bool SpinUntil(System.Func<bool> condition, System.TimeSpan timeout) { return default(bool); }
+  }
+
+  public partial class SynchronizationContext {
+    public SynchronizationContext() { }
+    public static System.Threading.SynchronizationContext Current { [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]get { return default(System.Threading.SynchronizationContext); } }
+    public virtual System.Threading.SynchronizationContext CreateCopy() { return default(System.Threading.SynchronizationContext); }
+    public bool IsWaitNotificationRequired() { return default(bool); }
+    public virtual void OperationCompleted() { }
+    public virtual void OperationStarted() { }
+    public virtual void Post(System.Threading.SendOrPostCallback d, object state) { }
+    public virtual void Send(System.Threading.SendOrPostCallback d, object state) { }
+    [System.Runtime.TargetedPatchingOptOutAttribute("Performance critical to inline across NGen image boundaries")]
+    [System.Security.SecurityCriticalAttribute]
+    public static void SetSynchronizationContext(System.Threading.SynchronizationContext syncContext) { }
+    [System.Security.SecurityCriticalAttribute]
+    public static void SetThreadStaticContext(System.Threading.SynchronizationContext syncContext) { }
+    [System.Security.SecuritySafeCriticalAttribute]
+    protected void SetWaitNotificationRequired() { }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.PrePrepareMethodAttribute]
+    [System.Security.SecurityCriticalAttribute]
+    public virtual int Wait(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) { return default(int); }
+    [System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.PrePrepareMethodAttribute]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(1))]
+    [System.Security.SecurityCriticalAttribute]
+    protected static int WaitHelper(System.IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout) { return default(int); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class SynchronizationLockException : System.SystemException {
+    public SynchronizationLockException() { }
+    protected SynchronizationLockException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public SynchronizationLockException(string message) { }
+    public SynchronizationLockException(string message, System.Exception innerException) { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public sealed partial class ThreadAbortException : System.SystemException {
+    internal ThreadAbortException() { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public partial class ThreadInterruptedException : System.SystemException {
+    public ThreadInterruptedException() { }
+    protected ThreadInterruptedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public ThreadInterruptedException(string message) { }
+    public ThreadInterruptedException(string message, System.Exception innerException) { }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("IsValueCreated={IsValueCreated}, Value={ValueForDebugDisplay}, Count={ValuesCountForDebugDisplay}")]
+  public partial class ThreadLocal<T> : System.IDisposable {
+    public ThreadLocal() { }
+    public ThreadLocal(bool trackAllValues) { }
+    public ThreadLocal(System.Func<T> valueFactory) { }
+    public ThreadLocal(System.Func<T> valueFactory, bool trackAllValues) { }
+    public bool IsValueCreated { get { return default(bool); } }
+    [System.Diagnostics.DebuggerBrowsableAttribute((System.Diagnostics.DebuggerBrowsableState)(0))]
+    public T Value { get { return default(T); } set { } }
+    public System.Collections.Generic.IList<T> Values { get { return default(System.Collections.Generic.IList<T>); } }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    ~ThreadLocal() { }
+    public override string ToString() { return default(string); }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(true)]
+  public enum ThreadPriority {
+    AboveNormal = 3,
+    BelowNormal = 1,
+    Highest = 4,
+    Lowest = 0,
+    Normal = 2,
+  }
+
+  public static partial class Volatile {
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static bool Read(ref bool location) { return default(bool); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static byte Read(ref byte location) { return default(byte); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static double Read(ref double location) { return default(double); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static short Read(ref short location) { return default(short); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static int Read(ref int location) { return default(int); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static long Read(ref long location) { return default(long); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static System.IntPtr Read(ref System.IntPtr location) { return default(System.IntPtr); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static sbyte Read(ref sbyte location) { return default(sbyte); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static float Read(ref float location) { return default(float); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static ushort Read(ref ushort location) { return default(ushort); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static uint Read(ref uint location) { return default(uint); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static ulong Read(ref ulong location) { return default(ulong); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static System.UIntPtr Read(ref System.UIntPtr location) { return default(System.UIntPtr); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static T Read<T>(ref T location) where T : class { return default(T); }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref bool location, bool value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref byte location, byte value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref double location, double value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref short location, short value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref int location, int value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref long location, long value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref System.IntPtr location, System.IntPtr value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref sbyte location, sbyte value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref float location, float value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref ushort location, ushort value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref uint location, uint value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref ulong location, ulong value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.CLSCompliantAttribute(false)]
+    [System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write(ref System.UIntPtr location, System.UIntPtr value) { }
+    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Runtime.ConstrainedExecution.ReliabilityContractAttribute((System.Runtime.ConstrainedExecution.Consistency)(3), (System.Runtime.ConstrainedExecution.Cer)(2))]
+    public static void Write<T>(ref T location, T value) where T : class { }
+  }
+
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class WaitHandleCannotBeOpenedException : System.ApplicationException {
+    public WaitHandleCannotBeOpenedException() { }
+    protected WaitHandleCannotBeOpenedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public WaitHandleCannotBeOpenedException(string message) { }
+    public WaitHandleCannotBeOpenedException(string message, System.Exception innerException) { }
+  }
+
+  [System.Diagnostics.DebuggerDisplayAttribute("Participant Count={ParticipantCount},Participants Remaining={ParticipantsRemaining}")]
+  [System.Runtime.InteropServices.ComVisibleAttribute(false)]
+  public partial class Barrier : System.IDisposable {
+    public Barrier(int participantCount) { }
+    public Barrier(int participantCount, System.Action<System.Threading.Barrier> postPhaseAction) { }
+    public long CurrentPhaseNumber { get { return default(long); } }
+    public int ParticipantCount { get { return default(int); } }
+    public int ParticipantsRemaining { get { return default(int); } }
+    public long AddParticipant() { return default(long); }
+    public long AddParticipants(int participantCount) { return default(long); }
+    public void Dispose() { }
+    protected virtual void Dispose(bool disposing) { }
+    public void RemoveParticipant() { }
+    public void RemoveParticipants(int participantCount) { }
+    public void SignalAndWait() { }
+    public bool SignalAndWait(int millisecondsTimeout) { return default(bool); }
+    public bool SignalAndWait(int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+    public void SignalAndWait(System.Threading.CancellationToken cancellationToken) { }
+    public bool SignalAndWait(System.TimeSpan timeout) { return default(bool); }
+    public bool SignalAndWait(System.TimeSpan timeout, System.Threading.CancellationToken cancellationToken) { return default(bool); }
+  }
+
+  public partial class BarrierPostPhaseException : System.Exception {
+    public BarrierPostPhaseException() { }
+    public BarrierPostPhaseException(System.Exception innerException) { }
+    [System.Security.SecurityCriticalAttribute]
+    protected BarrierPostPhaseException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+    public BarrierPostPhaseException(string message) { }
+    public BarrierPostPhaseException(string message, System.Exception innerException) { }
+  }
+
+  public enum LockRecursionPolicy {
+    NoRecursion = 0,
+    SupportsRecursion = 1,
+  }
+
+  public partial class ReaderWriterLockSlim : System.IDisposable {
+    public ReaderWriterLockSlim() { }
+    public ReaderWriterLockSlim(System.Threading.LockRecursionPolicy recursionPolicy) { }
+    public int CurrentReadCount { get { return default(int); } }
+    public bool IsReadLockHeld { get { return default(bool); } }
+    public bool IsUpgradeableReadLockHeld { get { return default(bool); } }
+    public bool IsWriteLockHeld { get { return default(bool); } }
+    public System.Threading.LockRecursionPolicy RecursionPolicy { get { return default(System.Threading.LockRecursionPolicy); } }
+    public int RecursiveReadCount { get { return default(int); } }
+    public int RecursiveUpgradeCount { get { return default(int); } }
+    public int RecursiveWriteCount { get { return default(int); } }
+    public int WaitingReadCount { get { return default(int); } }
+    public int WaitingUpgradeCount { get { return default(int); } }
+    public int WaitingWriteCount { get { return default(int); } }
+    public void Dispose() { }
+    public void EnterReadLock() { }
+    public void EnterUpgradeableReadLock() { }
+    public void EnterWriteLock() { }
+    public void ExitReadLock() { }
+    public void ExitUpgradeableReadLock() { }
+    public void ExitWriteLock() { }
+    public bool TryEnterReadLock(int millisecondsTimeout) { return default(bool); }
+    public bool TryEnterReadLock(System.TimeSpan timeout) { return default(bool); }
+    public bool TryEnterUpgradeableReadLock(int millisecondsTimeout) { return default(bool); }
+    public bool TryEnterUpgradeableReadLock(System.TimeSpan timeout) { return default(bool); }
+    public bool TryEnterWriteLock(int millisecondsTimeout) { return default(bool); }
+    public bool TryEnterWriteLock(System.TimeSpan timeout) { return default(bool); }
+  }
+
+} // end of System.Threading

fxdac/fxdac/Data/Contracts/System.Timer.cs

@@ -0,0 +1,50 @@
+[assembly:System.CLSCompliant(true)]
+namespace System.Timers {
+  public partial class ElapsedEventArgs : System.EventArgs {
+    internal ElapsedEventArgs() { }
+    public System.DateTime SignalTime { get { return default(System.DateTime); } }
+  }
+
+  public delegate void ElapsedEventHandler(object sender, System.Timers.ElapsedEventArgs e);
+
+  [System.ComponentModel.DefaultEventAttribute("Elapsed")]
+  [System.ComponentModel.DefaultPropertyAttribute("Interval")]
+  public partial class Timer : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize {
+    public Timer() { }
+    public Timer(double interval) { }
+    [System.ComponentModel.CategoryAttribute("Behavior")]
+    [System.ComponentModel.DefaultValueAttribute(true)]
+    [System.Timers.TimersDescriptionAttribute("TimerAutoReset")]
+    public bool AutoReset { get { return default(bool); } set { } }
+    [System.ComponentModel.CategoryAttribute("Behavior")]
+    [System.ComponentModel.DefaultValueAttribute(false)]
+    [System.Timers.TimersDescriptionAttribute("TimerEnabled")]
+    public bool Enabled { get { return default(bool); } set { } }
+    [System.ComponentModel.CategoryAttribute("Behavior")]
+    [System.ComponentModel.DefaultValueAttribute(100)]
+    [System.ComponentModel.SettingsBindableAttribute(true)]
+    [System.Timers.TimersDescriptionAttribute("TimerInterval")]
+    public double Interval { get { return default(double); } set { } }
+    public override System.ComponentModel.ISite Site { get { return default(System.ComponentModel.ISite); } set { } }
+    [System.ComponentModel.BrowsableAttribute(false)]
+    [System.ComponentModel.DefaultValueAttribute(null)]
+    [System.Timers.TimersDescriptionAttribute("TimerSynchronizingObject")]
+    public System.ComponentModel.ISynchronizeInvoke SynchronizingObject { get { return default(System.ComponentModel.ISynchronizeInvoke); } set { } }
+    [System.ComponentModel.CategoryAttribute("Behavior")]
+    [System.Timers.TimersDescriptionAttribute("TimerIntervalElapsed")]
+    public event System.Timers.ElapsedEventHandler Elapsed { add { } remove { } }
+    public void BeginInit() { }
+    public void Close() { }
+    protected override void Dispose(bool disposing) { }
+    public void EndInit() { }
+    public void Start() { }
+    public void Stop() { }
+  }
+
+  [System.AttributeUsageAttribute((System.AttributeTargets)(32767))]
+  public partial class TimersDescriptionAttribute : System.ComponentModel.DescriptionAttribute {
+    public TimersDescriptionAttribute(string description) { }
+    public override string Description { get { return default(string); } }
+  }
+
+} // end of System.Timers

fxdac/fxdac/Data/Contracts/System.Uri.Builder.cs

@@ -0,0 +1,88 @@
+[assembly:System.CLSCompliant(true)]
+namespace System {
+  public partial class FileStyleUriParser : System.UriParser {
+    public FileStyleUriParser() { }
+  }
+
+  public partial class FtpStyleUriParser : System.UriParser {
+    public FtpStyleUriParser() { }
+  }
+
+  public partial class GenericUriParser : System.UriParser {
+    public GenericUriParser(System.GenericUriParserOptions options) { }
+  }
+
+  [System.FlagsAttribute]
+  public enum GenericUriParserOptions {
+    AllowEmptyAuthority = 2,
+    Default = 0,
+    DontCompressPath = 128,
+    DontConvertPathBackslashes = 64,
+    DontUnescapePathDotsAndSlashes = 256,
+    GenericAuthority = 1,
+    Idn = 512,
+    IriParsing = 1024,
+    NoFragment = 32,
+    NoPort = 8,
+    NoQuery = 16,
+    NoUserInfo = 4,
+  }
+
+  public partial class HttpStyleUriParser : System.UriParser {
+    public HttpStyleUriParser() { }
+  }
+
+  public partial class NetPipeStyleUriParser : System.UriParser {
+    public NetPipeStyleUriParser() { }
+  }
+
+  public partial class NetTcpStyleUriParser : System.UriParser {
+    public NetTcpStyleUriParser() { }
+  }
+
+  public partial class NewsStyleUriParser : System.UriParser {
+    public NewsStyleUriParser() { }
+  }
+
+  public partial 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(System.Uri uri) { }
+    public string Fragment { get { return default(string); } set { } }
+    public string Host { get { return default(string); } set { } }
+    public string Password { get { return default(string); } set { } }
+    public string Path { get { return default(string); } set { } }
+    public int Port { get { return default(int); } set { } }
+    public string Query { get { return default(string); } set { } }
+    public string Scheme { get { return default(string); } set { } }
+    public System.Uri Uri { get { return default(System.Uri); } }
+    public string UserName { get { return default(string); } set { } }
+    public override bool Equals(object rparam) { return default(bool); }
+    public override int GetHashCode() { return default(int); }
+    public override string ToString() { return default(string); }
+  }
+
+  public enum UriIdnScope {
+    All = 2,
+    AllExceptIntranet = 1,
+    None = 0,
+  }
+
+  public abstract partial class UriParser {
+    protected UriParser() { }
+    protected internal virtual string GetComponents(System.Uri uri, System.UriComponents components, System.UriFormat format) { return default(string); }
+    protected internal virtual void InitializeAndValidate(System.Uri uri, out System.UriFormatException parsingError) { parsingError = default(System.UriFormatException); }
+    protected internal virtual bool IsBaseOf(System.Uri baseUri, System.Uri relativeUri) { return default(bool); }
+    public static bool IsKnownScheme(string schemeName) { return default(bool); }
+    protected internal virtual bool IsWellFormedOriginalString(System.Uri uri) { return default(bool); }
+    protected internal virtual System.UriParser OnNewUri() { return default(System.UriParser); }
+    protected virtual void OnRegister(string schemeName, int defaultPort) { }
+    public static void Register(System.UriParser uriParser, string schemeName, int defaultPort) { }
+    protected internal virtual string Resolve(System.Uri baseUri, System.Uri relativeUri, out System.UriFormatException parsingError) { parsingError = default(System.UriFormatException); return default(string); }
+  }
+
+} // end of System

fxdac/fxdac/Data/Contracts/System.Xml.XmlSerializer.cs

@@ -0,0 +1 @@
+[assembly:System.CLSCompliant(true)]