api diff between 2.2 and 3.0 netcoreapp

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0.md

@@ -0,0 +1,61 @@
+# API Difference netcoreapp2.2 vs netcoreapp3.0
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [Microsoft.VisualBasic](3.0.0_Microsoft.VisualBasic.md)
+* [Microsoft.VisualBasic.CompilerServices](3.0.0_Microsoft.VisualBasic.CompilerServices.md)
+* [Microsoft.VisualBasic.FileIO](3.0.0_Microsoft.VisualBasic.FileIO.md)
+* [System](3.0.0_System.md)
+* [System.Buffers](3.0.0_System.Buffers.md)
+* [System.Collections.Generic](3.0.0_System.Collections.Generic.md)
+* [System.Collections.Immutable](3.0.0_System.Collections.Immutable.md)
+* [System.ComponentModel](3.0.0_System.ComponentModel.md)
+* [System.ComponentModel.DataAnnotations](3.0.0_System.ComponentModel.DataAnnotations.md)
+* [System.Data](3.0.0_System.Data.md)
+* [System.Data.Common](3.0.0_System.Data.Common.md)
+* [System.Diagnostics](3.0.0_System.Diagnostics.md)
+* [System.Diagnostics.CodeAnalysis](3.0.0_System.Diagnostics.CodeAnalysis.md)
+* [System.Diagnostics.Tracing](3.0.0_System.Diagnostics.Tracing.md)
+* [System.Drawing](3.0.0_System.Drawing.md)
+* [System.Globalization](3.0.0_System.Globalization.md)
+* [System.IO](3.0.0_System.IO.md)
+* [System.IO.Compression](3.0.0_System.IO.Compression.md)
+* [System.IO.IsolatedStorage](3.0.0_System.IO.IsolatedStorage.md)
+* [System.IO.Pipes](3.0.0_System.IO.Pipes.md)
+* [System.Linq](3.0.0_System.Linq.md)
+* [System.Net](3.0.0_System.Net.md)
+* [System.Net.Http](3.0.0_System.Net.Http.md)
+* [System.Net.Security](3.0.0_System.Net.Security.md)
+* [System.Net.Sockets](3.0.0_System.Net.Sockets.md)
+* [System.Net.WebSockets](3.0.0_System.Net.WebSockets.md)
+* [System.Numerics](3.0.0_System.Numerics.md)
+* [System.Reflection](3.0.0_System.Reflection.md)
+* [System.Reflection.Emit](3.0.0_System.Reflection.Emit.md)
+* [System.Reflection.Metadata](3.0.0_System.Reflection.Metadata.md)
+* [System.Runtime](3.0.0_System.Runtime.md)
+* [System.Runtime.CompilerServices](3.0.0_System.Runtime.CompilerServices.md)
+* [System.Runtime.InteropServices](3.0.0_System.Runtime.InteropServices.md)
+* [System.Runtime.Intrinsics](3.0.0_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.X86](3.0.0_System.Runtime.Intrinsics.X86.md)
+* [System.Runtime.Loader](3.0.0_System.Runtime.Loader.md)
+* [System.Runtime.Remoting](3.0.0_System.Runtime.Remoting.md)
+* [System.Runtime.Serialization](3.0.0_System.Runtime.Serialization.md)
+* [System.Security](3.0.0_System.Security.md)
+* [System.Security.Authentication](3.0.0_System.Security.Authentication.md)
+* [System.Security.Cryptography](3.0.0_System.Security.Cryptography.md)
+* [System.Security.Permissions](3.0.0_System.Security.Permissions.md)
+* [System.Text](3.0.0_System.Text.md)
+* [System.Text.Encodings.Web](3.0.0_System.Text.Encodings.Web.md)
+* [System.Text.Json](3.0.0_System.Text.Json.md)
+* [System.Text.Json.Serialization](3.0.0_System.Text.Json.Serialization.md)
+* [System.Text.RegularExpressions](3.0.0_System.Text.RegularExpressions.md)
+* [System.Text.Unicode](3.0.0_System.Text.Unicode.md)
+* [System.Threading](3.0.0_System.Threading.md)
+* [System.Threading.Channels](3.0.0_System.Threading.Channels.md)
+* [System.Threading.Tasks](3.0.0_System.Threading.Tasks.md)
+* [System.Threading.Tasks.Sources](3.0.0_System.Threading.Tasks.Sources.md)
+* [System.Windows.Markup](3.0.0_System.Windows.Markup.md)
+* [System.Xml](3.0.0_System.Xml.md)
+* [System.Xml.Schema](3.0.0_System.Xml.Schema.md)
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_Microsoft.VisualBasic.CompilerServices.md

@@ -0,0 +1,163 @@
+# Microsoft.VisualBasic.CompilerServices
+
+``` diff
+ namespace Microsoft.VisualBasic.CompilerServices {
++    public sealed class BooleanType {
++        public static bool FromObject(object Value);
++        public static bool FromString(string Value);
++    }
++    public sealed class ByteType {
++        public static byte FromObject(object Value);
++        public static byte FromString(string Value);
++    }
++    public sealed class CharArrayType {
++        public static char[] FromObject(object Value);
++        public static char[] FromString(string Value);
++    }
++    public sealed class CharType {
++        public static char FromObject(object Value);
++        public static char FromString(string Value);
++    }
+     public sealed class Conversions {
++        public static object FallbackUserDefinedConversion(object Expression, Type TargetType);
++        public static string FromCharAndCount(char Value, int Count);
++        public static string FromCharArray(char[] Value);
++        public static string FromCharArraySubset(char[] Value, int StartIndex, int Length);
+         public static Decimal ToDecimal(bool Value);
+         public static Decimal ToDecimal(object Value);
+         public static Decimal ToDecimal(string Value);
+         public static string ToString(Decimal Value);
++        public static string ToString(decimal Value, NumberFormatInfo NumberFormat);
++        public static string ToString(double Value, NumberFormatInfo NumberFormat);
++        public static string ToString(float Value, NumberFormatInfo NumberFormat);
+     }
++    public sealed class DateType {
++        public static DateTime FromObject(object Value);
++        public static DateTime FromString(string Value);
++        public static DateTime FromString(string Value, CultureInfo culture);
++    }
++    public sealed class DecimalType {
++        public static decimal FromBoolean(bool Value);
++        public static decimal FromObject(object Value);
++        public static decimal FromObject(object Value, NumberFormatInfo NumberFormat);
++        public static decimal FromString(string Value);
++        public static decimal FromString(string Value, NumberFormatInfo NumberFormat);
++        public static decimal Parse(string Value, NumberFormatInfo NumberFormat);
++    }
++    public sealed class DoubleType {
++        public static double FromObject(object Value);
++        public static double FromObject(object Value, NumberFormatInfo NumberFormat);
++        public static double FromString(string Value);
++        public static double FromString(string Value, NumberFormatInfo NumberFormat);
++        public static double Parse(string Value);
++        public static double Parse(string Value, NumberFormatInfo NumberFormat);
++    }
++    public sealed class IntegerType {
++        public static int FromObject(object Value);
++        public static int FromString(string Value);
++    }
++    public sealed class LateBinding {
++        public static void LateCall(object o, Type objType, string name, object[] args, string[] paramnames, bool[] CopyBack);
++        public static object LateGet(object o, Type objType, string name, object[] args, string[] paramnames, bool[] CopyBack);
++        public static object LateIndexGet(object o, object[] args, string[] paramnames);
++        public static void LateIndexSet(object o, object[] args, string[] paramnames);
++        public static void LateIndexSetComplex(object o, object[] args, string[] paramnames, bool OptimisticSet, bool RValueBase);
++        public static void LateSet(object o, Type objType, string name, object[] args, string[] paramnames);
++        public static void LateSetComplex(object o, Type objType, string name, object[] args, string[] paramnames, bool OptimisticSet, bool RValueBase);
++    }
++    public sealed class LikeOperator {
++        public static object LikeObject(object Source, object Pattern, CompareMethod CompareOption);
++        public static bool LikeString(string Source, string Pattern, CompareMethod CompareOption);
++    }
++    public sealed class LongType {
++        public static long FromObject(object Value);
++        public static long FromString(string Value);
++    }
+     public sealed class NewLateBinding {
++        public static object FallbackCall(object Instance, string MemberName, object[] Arguments, string[] ArgumentNames, bool IgnoreReturn);
++        public static object FallbackGet(object Instance, string MemberName, object[] Arguments, string[] ArgumentNames);
++        public static void FallbackIndexSet(object Instance, object[] Arguments, string[] ArgumentNames);
++        public static void FallbackIndexSetComplex(object Instance, object[] Arguments, string[] ArgumentNames, bool OptimisticSet, bool RValueBase);
++        public static object FallbackInvokeDefault1(object Instance, object[] Arguments, string[] ArgumentNames, bool ReportErrors);
++        public static object FallbackInvokeDefault2(object Instance, object[] Arguments, string[] ArgumentNames, bool ReportErrors);
++        public static void FallbackSet(object Instance, string MemberName, object[] Arguments);
++        public static void FallbackSetComplex(object Instance, string MemberName, object[] Arguments, bool OptimisticSet, bool RValueBase);
++        public static object LateCallInvokeDefault(object Instance, object[] Arguments, string[] ArgumentNames, bool ReportErrors);
++        public static object LateGetInvokeDefault(object Instance, object[] Arguments, string[] ArgumentNames, bool ReportErrors);
+     }
+     public sealed class ObjectFlowControl {
+         public sealed class ForLoopControl {
+             public static bool ForNextCheckDec(Decimal count, Decimal limit, Decimal StepValue);
+         }
+     }
++    public sealed class ObjectType {
++        public ObjectType();
++        public static object AddObj(object o1, object o2);
++        public static object BitAndObj(object obj1, object obj2);
++        public static object BitOrObj(object obj1, object obj2);
++        public static object BitXorObj(object obj1, object obj2);
++        public static object DivObj(object o1, object o2);
++        public static object GetObjectValuePrimitive(object o);
++        public static object IDivObj(object o1, object o2);
++        public static bool LikeObj(object vLeft, object vRight, CompareMethod CompareOption);
++        public static object ModObj(object o1, object o2);
++        public static object MulObj(object o1, object o2);
++        public static object NegObj(object obj);
++        public static object NotObj(object obj);
++        public static int ObjTst(object o1, object o2, bool TextCompare);
++        public static object PlusObj(object obj);
++        public static object PowObj(object obj1, object obj2);
++        public static object ShiftLeftObj(object o1, int amount);
++        public static object ShiftRightObj(object o1, int amount);
++        public static object StrCatObj(object vLeft, object vRight);
++        public static object SubObj(object o1, object o2);
++        public static object XorObj(object obj1, object obj2);
++    }
+     public sealed class Operators {
++        public static object FallbackInvokeUserDefinedOperator(object vbOp, object[] arguments);
+     }
+     public sealed class ProjectData {
++        public static Exception CreateProjectError(int hr);
++        public static void EndApp();
+     }
++    public sealed class ShortType {
++        public static short FromObject(object Value);
++        public static short FromString(string Value);
++    }
++    public sealed class SingleType {
++        public static float FromObject(object Value);
++        public static float FromObject(object Value, NumberFormatInfo NumberFormat);
++        public static float FromString(string Value);
++        public static float FromString(string Value, NumberFormatInfo NumberFormat);
++    }
++    public sealed class StringType {
++        public static string FromBoolean(bool Value);
++        public static string FromByte(byte Value);
++        public static string FromChar(char Value);
++        public static string FromDate(DateTime Value);
++        public static string FromDecimal(decimal Value);
++        public static string FromDecimal(decimal Value, NumberFormatInfo NumberFormat);
++        public static string FromDouble(double Value);
++        public static string FromDouble(double Value, NumberFormatInfo NumberFormat);
++        public static string FromInteger(int Value);
++        public static string FromLong(long Value);
++        public static string FromObject(object Value);
++        public static string FromShort(short Value);
++        public static string FromSingle(float Value);
++        public static string FromSingle(float Value, NumberFormatInfo NumberFormat);
++        public static void MidStmtStr(ref string sDest, int StartPosition, int MaxInsertLength, string sInsert);
++        public static int StrCmp(string sLeft, string sRight, bool TextCompare);
++        public static bool StrLike(string Source, string Pattern, CompareMethod CompareOption);
++        public static bool StrLikeBinary(string Source, string Pattern);
++        public static bool StrLikeText(string Source, string Pattern);
++    }
++    public sealed class Versioned {
++        public static object CallByName(object Instance, string MethodName, CallType UseCallType, params object[] Arguments);
++        public static bool IsNumeric(object Expression);
++        public static string SystemTypeName(string VbName);
++        public static string TypeName(object Expression);
++        public static string VbTypeName(string SystemName);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_Microsoft.VisualBasic.FileIO.md

@@ -0,0 +1,142 @@
+# Microsoft.VisualBasic.FileIO
+
+``` diff
++namespace Microsoft.VisualBasic.FileIO {
++    public enum DeleteDirectoryOption {
++        DeleteAllContents = 5,
++        ThrowIfDirectoryNonEmpty = 4,
++    }
++    public enum FieldType {
++        Delimited = 0,
++        FixedWidth = 1,
++    }
++    public class FileSystem {
++        public FileSystem();
++        public static string CurrentDirectory { get; set; }
++        public static ReadOnlyCollection<DriveInfo> Drives { get; }
++        public static string CombinePath(string baseDirectory, string relativePath);
++        public static void CopyDirectory(string sourceDirectoryName, string destinationDirectoryName);
++        public static void CopyDirectory(string sourceDirectoryName, string destinationDirectoryName, UIOption showUI);
++        public static void CopyDirectory(string sourceDirectoryName, string destinationDirectoryName, UIOption showUI, UICancelOption onUserCancel);
++        public static void CopyDirectory(string sourceDirectoryName, string destinationDirectoryName, bool overwrite);
++        public static void CopyFile(string sourceFileName, string destinationFileName);
++        public static void CopyFile(string sourceFileName, string destinationFileName, UIOption showUI);
++        public static void CopyFile(string sourceFileName, string destinationFileName, UIOption showUI, UICancelOption onUserCancel);
++        public static void CopyFile(string sourceFileName, string destinationFileName, bool overwrite);
++        public static void CreateDirectory(string directory);
++        public static void DeleteDirectory(string directory, DeleteDirectoryOption onDirectoryNotEmpty);
++        public static void DeleteDirectory(string directory, UIOption showUI, RecycleOption recycle);
++        public static void DeleteDirectory(string directory, UIOption showUI, RecycleOption recycle, UICancelOption onUserCancel);
++        public static void DeleteFile(string file);
++        public static void DeleteFile(string file, UIOption showUI, RecycleOption recycle);
++        public static void DeleteFile(string file, UIOption showUI, RecycleOption recycle, UICancelOption onUserCancel);
++        public static bool DirectoryExists(string directory);
++        public static bool FileExists(string file);
++        public static ReadOnlyCollection<string> FindInFiles(string directory, string containsText, bool ignoreCase, SearchOption searchType);
++        public static ReadOnlyCollection<string> FindInFiles(string directory, string containsText, bool ignoreCase, SearchOption searchType, params string[] fileWildcards);
++        public static ReadOnlyCollection<string> GetDirectories(string directory);
++        public static ReadOnlyCollection<string> GetDirectories(string directory, SearchOption searchType, params string[] wildcards);
++        public static DirectoryInfo GetDirectoryInfo(string directory);
++        public static DriveInfo GetDriveInfo(string drive);
++        public static FileInfo GetFileInfo(string file);
++        public static ReadOnlyCollection<string> GetFiles(string directory);
++        public static ReadOnlyCollection<string> GetFiles(string directory, SearchOption searchType, params string[] wildcards);
++        public static string GetName(string path);
++        public static string GetParentPath(string path);
++        public static string GetTempFileName();
++        public static void MoveDirectory(string sourceDirectoryName, string destinationDirectoryName);
++        public static void MoveDirectory(string sourceDirectoryName, string destinationDirectoryName, UIOption showUI);
++        public static void MoveDirectory(string sourceDirectoryName, string destinationDirectoryName, UIOption showUI, UICancelOption onUserCancel);
++        public static void MoveDirectory(string sourceDirectoryName, string destinationDirectoryName, bool overwrite);
++        public static void MoveFile(string sourceFileName, string destinationFileName);
++        public static void MoveFile(string sourceFileName, string destinationFileName, UIOption showUI);
++        public static void MoveFile(string sourceFileName, string destinationFileName, UIOption showUI, UICancelOption onUserCancel);
++        public static void MoveFile(string sourceFileName, string destinationFileName, bool overwrite);
++        public static TextFieldParser OpenTextFieldParser(string file);
++        public static TextFieldParser OpenTextFieldParser(string file, params int[] fieldWidths);
++        public static TextFieldParser OpenTextFieldParser(string file, params string[] delimiters);
++        public static StreamReader OpenTextFileReader(string file);
++        public static StreamReader OpenTextFileReader(string file, Encoding encoding);
++        public static StreamWriter OpenTextFileWriter(string file, bool append);
++        public static StreamWriter OpenTextFileWriter(string file, bool append, Encoding encoding);
++        public static byte[] ReadAllBytes(string file);
++        public static string ReadAllText(string file);
++        public static string ReadAllText(string file, Encoding encoding);
++        public static void RenameDirectory(string directory, string newName);
++        public static void RenameFile(string file, string newName);
++        public static void WriteAllBytes(string file, byte[] data, bool append);
++        public static void WriteAllText(string file, string text, bool append);
++        public static void WriteAllText(string file, string text, bool append, Encoding encoding);
++    }
++    public class MalformedLineException : Exception {
++        public MalformedLineException();
++        protected MalformedLineException(SerializationInfo info, StreamingContext context);
++        public MalformedLineException(string message);
++        public MalformedLineException(string message, Exception innerException);
++        public MalformedLineException(string message, long lineNumber);
++        public MalformedLineException(string message, long lineNumber, Exception innerException);
++        public long LineNumber { get; set; }
++        public override void GetObjectData(SerializationInfo info, StreamingContext context);
++        public override string ToString();
++    }
++    public enum RecycleOption {
++        DeletePermanently = 2,
++        SendToRecycleBin = 3,
++    }
++    public enum SearchOption {
++        SearchAllSubDirectories = 3,
++        SearchTopLevelOnly = 2,
++    }
++    public class SpecialDirectories {
++        public SpecialDirectories();
++        public static string AllUsersApplicationData { get; }
++        public static string CurrentUserApplicationData { get; }
++        public static string Desktop { get; }
++        public static string MyDocuments { get; }
++        public static string MyMusic { get; }
++        public static string MyPictures { get; }
++        public static string ProgramFiles { get; }
++        public static string Programs { get; }
++        public static string Temp { get; }
++    }
++    public class TextFieldParser : IDisposable {
++        public TextFieldParser(Stream stream);
++        public TextFieldParser(Stream stream, Encoding defaultEncoding);
++        public TextFieldParser(Stream stream, Encoding defaultEncoding, bool detectEncoding);
++        public TextFieldParser(Stream stream, Encoding defaultEncoding, bool detectEncoding, bool leaveOpen);
++        public TextFieldParser(TextReader reader);
++        public TextFieldParser(string path);
++        public TextFieldParser(string path, Encoding defaultEncoding);
++        public TextFieldParser(string path, Encoding defaultEncoding, bool detectEncoding);
++        public string[] CommentTokens { get; set; }
++        public string[] Delimiters { get; set; }
++        public bool EndOfData { get; }
++        public string ErrorLine { get; }
++        public long ErrorLineNumber { get; }
++        public int[] FieldWidths { get; set; }
++        public bool HasFieldsEnclosedInQuotes { get; set; }
++        public long LineNumber { get; }
++        public FieldType TextFieldType { get; set; }
++        public bool TrimWhiteSpace { get; set; }
++        public void Close();
++        protected virtual void Dispose(bool disposing);
++        ~TextFieldParser();
++        public string PeekChars(int numberOfChars);
++        public string[] ReadFields();
++        public string ReadLine();
++        public string ReadToEnd();
++        public void SetDelimiters(params string[] delimiters);
++        public void SetFieldWidths(params int[] fieldWidths);
++        void System.IDisposable.Dispose();
++    }
++    public enum UICancelOption {
++        DoNothing = 2,
++        ThrowException = 3,
++    }
++    public enum UIOption {
++        AllDialogs = 3,
++        OnlyErrorDialogs = 2,
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_Microsoft.VisualBasic.md

@@ -0,0 +1,589 @@
+# Microsoft.VisualBasic
+
+``` diff
+ namespace Microsoft.VisualBasic {
++    public enum AppWinStyle : short {
++        Hide = (short)0,
++        MaximizedFocus = (short)3,
++        MinimizedFocus = (short)2,
++        MinimizedNoFocus = (short)6,
++        NormalFocus = (short)1,
++        NormalNoFocus = (short)4,
++    }
++    public sealed class Collection : ICollection, IEnumerable, IList {
++        public Collection();
++        public int Count { get; }
++        int System.Collections.ICollection.Count { get; }
++        bool System.Collections.ICollection.IsSynchronized { get; }
++        object System.Collections.ICollection.SyncRoot { get; }
++        bool System.Collections.IList.IsFixedSize { get; }
++        bool System.Collections.IList.IsReadOnly { get; }
++        object System.Collections.IList.this[int index] { get; set; }
++        public object this[int Index] { get; }
++        public object this[object Index] { get; }
++        public object this[string Key] { get; }
++        public void Add(object Item, string Key = null, object Before = null, object After = null);
++        public void Clear();
++        public bool Contains(string Key);
++        public IEnumerator GetEnumerator();
++        public void Remove(int Index);
++        public void Remove(string Key);
++        void System.Collections.ICollection.CopyTo(Array array, int index);
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        int System.Collections.IList.Add(object value);
++        void System.Collections.IList.Clear();
++        bool System.Collections.IList.Contains(object value);
++        int System.Collections.IList.IndexOf(object value);
++        void System.Collections.IList.Insert(int index, object value);
++        void System.Collections.IList.Remove(object value);
++        void System.Collections.IList.RemoveAt(int index);
++    }
++    public sealed class ComClassAttribute : Attribute {
++        public ComClassAttribute();
++        public ComClassAttribute(string _ClassID);
++        public ComClassAttribute(string _ClassID, string _InterfaceID);
++        public ComClassAttribute(string _ClassID, string _InterfaceID, string _EventId);
++        public string ClassID { get; }
++        public string EventID { get; }
++        public string InterfaceID { get; }
++        public bool InterfaceShadows { get; set; }
++    }
++    public enum CompareMethod {
++        Binary = 0,
++        Text = 1,
++    }
+     public sealed class Constants {
++        public const AppWinStyle vbHide = AppWinStyle.Hide;
++        public const AppWinStyle vbMaximizedFocus = AppWinStyle.MaximizedFocus;
++        public const AppWinStyle vbMinimizedFocus = AppWinStyle.MinimizedFocus;
++        public const AppWinStyle vbMinimizedNoFocus = AppWinStyle.MinimizedNoFocus;
++        public const AppWinStyle vbNormalFocus = AppWinStyle.NormalFocus;
++        public const AppWinStyle vbNormalNoFocus = AppWinStyle.NormalNoFocus;
++        public const CallType vbGet = CallType.Get;
++        public const CallType vbLet = CallType.Let;
++        public const CallType vbMethod = CallType.Method;
++        public const CallType vbSet = CallType.Set;
++        public const CompareMethod vbBinaryCompare = CompareMethod.Binary;
++        public const CompareMethod vbTextCompare = CompareMethod.Text;
++        public const DateFormat vbGeneralDate = DateFormat.GeneralDate;
++        public const DateFormat vbLongDate = DateFormat.LongDate;
++        public const DateFormat vbLongTime = DateFormat.LongTime;
++        public const DateFormat vbShortDate = DateFormat.ShortDate;
++        public const DateFormat vbShortTime = DateFormat.ShortTime;
++        public const FileAttribute vbArchive = FileAttribute.Archive;
++        public const FileAttribute vbDirectory = FileAttribute.Directory;
++        public const FileAttribute vbHidden = FileAttribute.Hidden;
++        public const FileAttribute vbNormal = FileAttribute.Normal;
++        public const FileAttribute vbReadOnly = FileAttribute.ReadOnly;
++        public const FileAttribute vbSystem = FileAttribute.System;
++        public const FileAttribute vbVolume = FileAttribute.Volume;
++        public const FirstDayOfWeek vbFriday = FirstDayOfWeek.Friday;
++        public const FirstDayOfWeek vbMonday = FirstDayOfWeek.Monday;
++        public const FirstDayOfWeek vbSaturday = FirstDayOfWeek.Saturday;
++        public const FirstDayOfWeek vbSunday = FirstDayOfWeek.Sunday;
++        public const FirstDayOfWeek vbThursday = FirstDayOfWeek.Thursday;
++        public const FirstDayOfWeek vbTuesday = FirstDayOfWeek.Tuesday;
++        public const FirstDayOfWeek vbUseSystemDayOfWeek = FirstDayOfWeek.System;
++        public const FirstDayOfWeek vbWednesday = FirstDayOfWeek.Wednesday;
++        public const FirstWeekOfYear vbFirstFourDays = FirstWeekOfYear.FirstFourDays;
++        public const FirstWeekOfYear vbFirstFullWeek = FirstWeekOfYear.FirstFullWeek;
++        public const FirstWeekOfYear vbFirstJan1 = FirstWeekOfYear.Jan1;
++        public const FirstWeekOfYear vbUseSystem = FirstWeekOfYear.System;
++        public const MsgBoxResult vbAbort = MsgBoxResult.Abort;
++        public const MsgBoxResult vbCancel = MsgBoxResult.Cancel;
++        public const MsgBoxResult vbIgnore = MsgBoxResult.Ignore;
++        public const MsgBoxResult vbNo = MsgBoxResult.No;
++        public const MsgBoxResult vbOK = MsgBoxResult.Ok;
++        public const MsgBoxResult vbRetry = MsgBoxResult.Retry;
++        public const MsgBoxResult vbYes = MsgBoxResult.Yes;
++        public const MsgBoxStyle vbAbortRetryIgnore = MsgBoxStyle.AbortRetryIgnore;
++        public const MsgBoxStyle vbApplicationModal = MsgBoxStyle.ApplicationModal;
++        public const MsgBoxStyle vbCritical = MsgBoxStyle.Critical;
++        public const MsgBoxStyle vbDefaultButton1 = MsgBoxStyle.ApplicationModal;
++        public const MsgBoxStyle vbDefaultButton2 = MsgBoxStyle.DefaultButton2;
++        public const MsgBoxStyle vbDefaultButton3 = MsgBoxStyle.DefaultButton3;
++        public const MsgBoxStyle vbExclamation = MsgBoxStyle.Exclamation;
++        public const MsgBoxStyle vbInformation = MsgBoxStyle.Information;
++        public const MsgBoxStyle vbMsgBoxHelp = MsgBoxStyle.MsgBoxHelp;
++        public const MsgBoxStyle vbMsgBoxRight = MsgBoxStyle.MsgBoxRight;
++        public const MsgBoxStyle vbMsgBoxRtlReading = MsgBoxStyle.MsgBoxRtlReading;
++        public const MsgBoxStyle vbMsgBoxSetForeground = MsgBoxStyle.MsgBoxSetForeground;
++        public const MsgBoxStyle vbOKCancel = MsgBoxStyle.OkCancel;
++        public const MsgBoxStyle vbOKOnly = MsgBoxStyle.ApplicationModal;
++        public const MsgBoxStyle vbQuestion = MsgBoxStyle.Question;
++        public const MsgBoxStyle vbRetryCancel = MsgBoxStyle.RetryCancel;
++        public const MsgBoxStyle vbSystemModal = MsgBoxStyle.SystemModal;
++        public const MsgBoxStyle vbYesNo = MsgBoxStyle.YesNo;
++        public const MsgBoxStyle vbYesNoCancel = MsgBoxStyle.YesNoCancel;
++        public const TriState vbFalse = TriState.False;
++        public const TriState vbTrue = TriState.True;
++        public const TriState vbUseDefault = TriState.UseDefault;
++        public const VariantType vbArray = VariantType.Array;
++        public const VariantType vbBoolean = VariantType.Boolean;
++        public const VariantType vbByte = VariantType.Byte;
++        public const VariantType vbCurrency = VariantType.Currency;
++        public const VariantType vbDate = VariantType.Date;
++        public const VariantType vbDecimal = VariantType.Decimal;
++        public const VariantType vbDouble = VariantType.Double;
++        public const VariantType vbEmpty = VariantType.Empty;
++        public const VariantType vbInteger = VariantType.Integer;
++        public const VariantType vbLong = VariantType.Long;
++        public const VariantType vbNull = VariantType.Null;
++        public const VariantType vbObject = VariantType.Object;
++        public const VariantType vbSingle = VariantType.Single;
++        public const VariantType vbString = VariantType.String;
++        public const VariantType vbUserDefinedType = VariantType.UserDefinedType;
++        public const VariantType vbVariant = VariantType.Variant;
++        public const VbStrConv vbHiragana = VbStrConv.Hiragana;
++        public const VbStrConv vbKatakana = VbStrConv.Katakana;
++        public const VbStrConv vbLinguisticCasing = VbStrConv.LinguisticCasing;
++        public const VbStrConv vbLowerCase = VbStrConv.Lowercase;
++        public const VbStrConv vbNarrow = VbStrConv.Narrow;
++        public const VbStrConv vbProperCase = VbStrConv.ProperCase;
++        public const VbStrConv vbSimplifiedChinese = VbStrConv.SimplifiedChinese;
++        public const VbStrConv vbTraditionalChinese = VbStrConv.TraditionalChinese;
++        public const VbStrConv vbUpperCase = VbStrConv.Uppercase;
++        public const VbStrConv vbWide = VbStrConv.Wide;
++        public const int vbObjectError = -2147221504;
+     }
++    public sealed class ControlChars {
++        public const char Back = '\b';
++        public const char Cr = '\r';
++        public const char FormFeed = '\f';
++        public const char Lf = '\n';
++        public const char NullChar = '\0';
++        public const char Quote = '"';
++        public const char Tab = '\t';
++        public const char VerticalTab = '\v';
++        public const string CrLf = "\r\n";
++        public const string NewLine = "\r\n";
++        public ControlChars();
++    }
++    public sealed class Conversion {
++        public static object CTypeDynamic(object Expression, Type TargetType);
++        public static TargetType CTypeDynamic<TargetType>(object Expression);
++        public static string ErrorToString();
++        public static string ErrorToString(int ErrorNumber);
++        public static decimal Fix(decimal Number);
++        public static double Fix(double Number);
++        public static short Fix(short Number);
++        public static int Fix(int Number);
++        public static long Fix(long Number);
++        public static object Fix(object Number);
++        public static float Fix(float Number);
++        public static string Hex(byte Number);
++        public static string Hex(short Number);
++        public static string Hex(int Number);
++        public static string Hex(long Number);
++        public static string Hex(object Number);
++        public static string Hex(sbyte Number);
++        public static string Hex(ushort Number);
++        public static string Hex(uint Number);
++        public static string Hex(ulong Number);
++        public static decimal Int(decimal Number);
++        public static double Int(double Number);
++        public static short Int(short Number);
++        public static int Int(int Number);
++        public static long Int(long Number);
++        public static object Int(object Number);
++        public static float Int(float Number);
++        public static string Oct(byte Number);
++        public static string Oct(short Number);
++        public static string Oct(int Number);
++        public static string Oct(long Number);
++        public static string Oct(object Number);
++        public static string Oct(sbyte Number);
++        public static string Oct(ushort Number);
++        public static string Oct(uint Number);
++        public static string Oct(ulong Number);
++        public static string Str(object Number);
++        public static int Val(char Expression);
++        public static double Val(object Expression);
++        public static double Val(string InputStr);
++    }
++    public sealed class DateAndTime {
++        public static string DateString { get; set; }
++        public static DateTime Now { get; }
++        public static DateTime TimeOfDay { get; set; }
++        public static double Timer { get; }
++        public static string TimeString { get; set; }
++        public static DateTime Today { get; set; }
++        public static DateTime DateAdd(DateInterval Interval, double Number, DateTime DateValue);
++        public static DateTime DateAdd(string Interval, double Number, object DateValue);
++        public static long DateDiff(DateInterval Interval, DateTime Date1, DateTime Date2, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday, FirstWeekOfYear WeekOfYear = FirstWeekOfYear.Jan1);
++        public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday, FirstWeekOfYear WeekOfYear = FirstWeekOfYear.Jan1);
++        public static int DatePart(DateInterval Interval, DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue = FirstDayOfWeek.Sunday, FirstWeekOfYear FirstWeekOfYearValue = FirstWeekOfYear.Jan1);
++        public static int DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday, FirstWeekOfYear WeekOfYear = FirstWeekOfYear.Jan1);
++        public static DateTime DateSerial(int Year, int Month, int Day);
++        public static DateTime DateValue(string StringDate);
++        public static int Day(DateTime DateValue);
++        public static int Hour(DateTime TimeValue);
++        public static int Minute(DateTime TimeValue);
++        public static int Month(DateTime DateValue);
++        public static string MonthName(int Month, bool Abbreviate = false);
++        public static int Second(DateTime TimeValue);
++        public static DateTime TimeSerial(int Hour, int Minute, int Second);
++        public static DateTime TimeValue(string StringTime);
++        public static int Weekday(DateTime DateValue, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday);
++        public static string WeekdayName(int Weekday, bool Abbreviate = false, FirstDayOfWeek FirstDayOfWeekValue = FirstDayOfWeek.System);
++        public static int Year(DateTime DateValue);
++    }
++    public enum DateFormat {
++        GeneralDate = 0,
++        LongDate = 1,
++        LongTime = 3,
++        ShortDate = 2,
++        ShortTime = 4,
++    }
++    public enum DateInterval {
++        Day = 4,
++        DayOfYear = 3,
++        Hour = 7,
++        Minute = 8,
++        Month = 2,
++        Quarter = 1,
++        Second = 9,
++        Weekday = 6,
++        WeekOfYear = 5,
++        Year = 0,
++    }
++    public enum DueDate {
++        BegOfPeriod = 1,
++        EndOfPeriod = 0,
++    }
++    public sealed class ErrObject {
++        public string Description { get; set; }
++        public int Erl { get; }
++        public int LastDllError { get; }
++        public int Number { get; set; }
++        public void Clear();
++        public Exception GetException();
++        public void Raise(int Number, object Source = null, object Description = null, object HelpFile = null, object HelpContext = null);
++    }
++    public enum FileAttribute {
++        Archive = 32,
++        Directory = 16,
++        Hidden = 2,
++        Normal = 0,
++        ReadOnly = 1,
++        System = 4,
++        Volume = 8,
++    }
++    public sealed class FileSystem {
++        public static void ChDir(string Path);
++        public static void ChDrive(char Drive);
++        public static void ChDrive(string Drive);
++        public static string CurDir();
++        public static string CurDir(char Drive);
++        public static string Dir();
++        public static string Dir(string PathName, FileAttribute Attributes = FileAttribute.Normal);
++        public static bool EOF(int FileNumber);
++        public static OpenMode FileAttr(int FileNumber);
++        public static void FileClose(params int[] FileNumbers);
++        public static void FileCopy(string Source, string Destination);
++        public static DateTime FileDateTime(string PathName);
++        public static void FileGet(int FileNumber, ref Array Value, long RecordNumber = (long)-1, bool ArrayIsDynamic = false, bool StringIsFixedLength = false);
++        public static void FileGet(int FileNumber, ref bool Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref byte Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref char Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref DateTime Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref decimal Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref double Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref short Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref int Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref long Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref float Value, long RecordNumber = (long)-1);
++        public static void FileGet(int FileNumber, ref string Value, long RecordNumber = (long)-1, bool StringIsFixedLength = false);
++        public static void FileGet(int FileNumber, ref ValueType Value, long RecordNumber = (long)-1);
++        public static void FileGetObject(int FileNumber, ref object Value, long RecordNumber = (long)-1);
++        public static long FileLen(string PathName);
++        public static void FileOpen(int FileNumber, string FileName, OpenMode Mode, OpenAccess Access = OpenAccess.Default, OpenShare Share = OpenShare.Default, int RecordLength = -1);
++        public static void FilePut(int FileNumber, Array Value, long RecordNumber = (long)-1, bool ArrayIsDynamic = false, bool StringIsFixedLength = false);
++        public static void FilePut(int FileNumber, bool Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, byte Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, char Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, DateTime Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, decimal Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, double Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, short Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, int Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, long Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, float Value, long RecordNumber = (long)-1);
++        public static void FilePut(int FileNumber, string Value, long RecordNumber = (long)-1, bool StringIsFixedLength = false);
++        public static void FilePut(int FileNumber, ValueType Value, long RecordNumber = (long)-1);
++        public static void FilePut(object FileNumber, object Value, object RecordNumber);
++        public static void FilePutObject(int FileNumber, object Value, long RecordNumber = (long)-1);
++        public static void FileWidth(int FileNumber, int RecordWidth);
++        public static int FreeFile();
++        public static FileAttribute GetAttr(string PathName);
++        public static void Input(int FileNumber, ref bool Value);
++        public static void Input(int FileNumber, ref byte Value);
++        public static void Input(int FileNumber, ref char Value);
++        public static void Input(int FileNumber, ref DateTime Value);
++        public static void Input(int FileNumber, ref decimal Value);
++        public static void Input(int FileNumber, ref double Value);
++        public static void Input(int FileNumber, ref short Value);
++        public static void Input(int FileNumber, ref int Value);
++        public static void Input(int FileNumber, ref long Value);
++        public static void Input(int FileNumber, ref object Value);
++        public static void Input(int FileNumber, ref float Value);
++        public static void Input(int FileNumber, ref string Value);
++        public static string InputString(int FileNumber, int CharCount);
++        public static void Kill(string PathName);
++        public static string LineInput(int FileNumber);
++        public static long Loc(int FileNumber);
++        public static void Lock(int FileNumber);
++        public static void Lock(int FileNumber, long Record);
++        public static void Lock(int FileNumber, long FromRecord, long ToRecord);
++        public static long LOF(int FileNumber);
++        public static void MkDir(string Path);
++        public static void Print(int FileNumber, params object[] Output);
++        public static void PrintLine(int FileNumber, params object[] Output);
++        public static void Rename(string OldPath, string NewPath);
++        public static void Reset();
++        public static void RmDir(string Path);
++        public static long Seek(int FileNumber);
++        public static void Seek(int FileNumber, long Position);
++        public static void SetAttr(string PathName, FileAttribute Attributes);
++        public static SpcInfo SPC(short Count);
++        public static TabInfo TAB();
++        public static TabInfo TAB(short Column);
++        public static void Unlock(int FileNumber);
++        public static void Unlock(int FileNumber, long Record);
++        public static void Unlock(int FileNumber, long FromRecord, long ToRecord);
++        public static void Write(int FileNumber, params object[] Output);
++        public static void WriteLine(int FileNumber, params object[] Output);
++    }
++    public sealed class Financial {
++        public static double DDB(double Cost, double Salvage, double Life, double Period, double Factor = 2);
++        public static double FV(double Rate, double NPer, double Pmt, double PV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double IPmt(double Rate, double Per, double NPer, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double IRR(ref double[] ValueArray, double Guess = 0.1);
++        public static double MIRR(ref double[] ValueArray, double FinanceRate, double ReinvestRate);
++        public static double NPer(double Rate, double Pmt, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double NPV(double Rate, ref double[] ValueArray);
++        public static double Pmt(double Rate, double NPer, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double PPmt(double Rate, double Per, double NPer, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double PV(double Rate, double NPer, double Pmt, double FV = 0, DueDate Due = DueDate.EndOfPeriod);
++        public static double Rate(double NPer, double Pmt, double PV, double FV = 0, DueDate Due = DueDate.EndOfPeriod, double Guess = 0.1);
++        public static double SLN(double Cost, double Salvage, double Life);
++        public static double SYD(double Cost, double Salvage, double Life, double Period);
++    }
++    public enum FirstDayOfWeek {
++        Friday = 6,
++        Monday = 2,
++        Saturday = 7,
++        Sunday = 1,
++        System = 0,
++        Thursday = 5,
++        Tuesday = 3,
++        Wednesday = 4,
++    }
++    public enum FirstWeekOfYear {
++        FirstFourDays = 2,
++        FirstFullWeek = 3,
++        Jan1 = 1,
++        System = 0,
++    }
++    public sealed class Information {
++        public static ErrObject Err();
++        public static bool IsArray(object VarName);
++        public static bool IsDate(object Expression);
++        public static bool IsDBNull(object Expression);
++        public static bool IsError(object Expression);
++        public static bool IsNothing(object Expression);
++        public static bool IsNumeric(object Expression);
++        public static bool IsReference(object Expression);
++        public static int LBound(Array Array, int Rank = 1);
++        public static int QBColor(int Color);
++        public static int RGB(int Red, int Green, int Blue);
++        public static string SystemTypeName(string VbName);
++        public static string TypeName(object VarName);
++        public static int UBound(Array Array, int Rank = 1);
++        public static VariantType VarType(object VarName);
++        public static string VbTypeName(string UrtName);
++    }
++    public sealed class Interaction {
++        public static void Beep();
++        public static object CallByName(object ObjectRef, string ProcName, CallType UseCallType, params object[] Args);
++        public static object CreateObject(string ProgId, string ServerName = "");
++        public static object IIf(bool Expression, object TruePart, object FalsePart);
++    }
++    public enum MsgBoxResult {
++        Abort = 3,
++        Cancel = 2,
++        Ignore = 5,
++        No = 7,
++        Ok = 1,
++        Retry = 4,
++        Yes = 6,
++    }
++    public enum MsgBoxStyle {
++        AbortRetryIgnore = 2,
++        ApplicationModal = 0,
++        Critical = 16,
++        DefaultButton1 = 0,
++        DefaultButton2 = 256,
++        DefaultButton3 = 512,
++        Exclamation = 48,
++        Information = 64,
++        MsgBoxHelp = 16384,
++        MsgBoxRight = 524288,
++        MsgBoxRtlReading = 1048576,
++        MsgBoxSetForeground = 65536,
++        OkCancel = 1,
++        OkOnly = 0,
++        Question = 32,
++        RetryCancel = 5,
++        SystemModal = 4096,
++        YesNo = 4,
++        YesNoCancel = 3,
++    }
++    public sealed class MyGroupCollectionAttribute : Attribute {
++        public MyGroupCollectionAttribute(string typeToCollect, string createInstanceMethodName, string disposeInstanceMethodName, string defaultInstanceAlias);
++        public string CreateMethod { get; }
++        public string DefaultInstanceAlias { get; }
++        public string DisposeMethod { get; }
++        public string MyGroupName { get; }
++    }
++    public enum OpenAccess {
++        Default = -1,
++        Read = 1,
++        ReadWrite = 3,
++        Write = 2,
++    }
++    public enum OpenMode {
++        Append = 8,
++        Binary = 32,
++        Input = 1,
++        Output = 2,
++        Random = 4,
++    }
++    public enum OpenShare {
++        Default = -1,
++        LockRead = 2,
++        LockReadWrite = 0,
++        LockWrite = 1,
++        Shared = 3,
++    }
++    public struct SpcInfo {
++        public short Count;
++    }
+     public sealed class Strings {
++        public static int Asc(char String);
++        public static int Asc(string String);
++        public static char Chr(int CharCode);
++        public static string[] Filter(object[] Source, string Match, bool Include = true, CompareMethod Compare = CompareMethod.Binary);
++        public static string[] Filter(string[] Source, string Match, bool Include = true, CompareMethod Compare = CompareMethod.Binary);
++        public static string Format(object Expression, string Style = "");
++        public static string FormatCurrency(object Expression, int NumDigitsAfterDecimal = -1, TriState IncludeLeadingDigit = TriState.UseDefault, TriState UseParensForNegativeNumbers = TriState.UseDefault, TriState GroupDigits = TriState.UseDefault);
++        public static string FormatDateTime(DateTime Expression, DateFormat NamedFormat = DateFormat.GeneralDate);
++        public static string FormatNumber(object Expression, int NumDigitsAfterDecimal = -1, TriState IncludeLeadingDigit = TriState.UseDefault, TriState UseParensForNegativeNumbers = TriState.UseDefault, TriState GroupDigits = TriState.UseDefault);
++        public static string FormatPercent(object Expression, int NumDigitsAfterDecimal = -1, TriState IncludeLeadingDigit = TriState.UseDefault, TriState UseParensForNegativeNumbers = TriState.UseDefault, TriState GroupDigits = TriState.UseDefault);
++        public static char GetChar(string str, int Index);
++        public static int InStr(int StartPos, string String1, string String2, CompareMethod Compare = CompareMethod.Binary);
++        public static int InStr(string String1, string String2, CompareMethod Compare = CompareMethod.Binary);
++        public static int InStrRev(string StringCheck, string StringMatch, int Start = -1, CompareMethod Compare = CompareMethod.Binary);
++        public static string Join(object[] SourceArray, string Delimiter = " ");
++        public static string Join(string[] SourceArray, string Delimiter = " ");
++        public static char LCase(char Value);
++        public static string LCase(string Value);
++        public static string Left(string str, int Length);
++        public static int Len(bool Expression);
++        public static int Len(byte Expression);
++        public static int Len(char Expression);
++        public static int Len(DateTime Expression);
++        public static int Len(decimal Expression);
++        public static int Len(double Expression);
++        public static int Len(short Expression);
++        public static int Len(int Expression);
++        public static int Len(long Expression);
++        public static int Len(object Expression);
++        public static int Len(sbyte Expression);
++        public static int Len(float Expression);
++        public static int Len(string Expression);
++        public static int Len(ushort Expression);
++        public static int Len(uint Expression);
++        public static int Len(ulong Expression);
++        public static string LSet(string Source, int Length);
++        public static string LTrim(string str);
++        public static string Mid(string str, int Start);
++        public static string Mid(string str, int Start, int Length);
++        public static string Replace(string Expression, string Find, string Replacement, int Start = 1, int Count = -1, CompareMethod Compare = CompareMethod.Binary);
++        public static string Right(string str, int Length);
++        public static string RSet(string Source, int Length);
++        public static string RTrim(string str);
++        public static string Space(int Number);
++        public static string[] Split(string Expression, string Delimiter = " ", int Limit = -1, CompareMethod Compare = CompareMethod.Binary);
++        public static int StrComp(string String1, string String2, CompareMethod Compare = CompareMethod.Binary);
++        public static string StrConv(string str, VbStrConv Conversion, int LocaleID = 0);
++        public static string StrDup(int Number, char Character);
++        public static object StrDup(int Number, object Character);
++        public static string StrDup(int Number, string Character);
++        public static string StrReverse(string Expression);
++        public static string Trim(string str);
++        public static char UCase(char Value);
++        public static string UCase(string Value);
+     }
++    public struct TabInfo {
++        public short Column;
++    }
++    public enum TriState {
++        False = 0,
++        True = -1,
++        UseDefault = -2,
++    }
++    public enum VariantType {
++        Array = 8192,
++        Boolean = 11,
++        Byte = 17,
++        Char = 18,
++        Currency = 6,
++        DataObject = 13,
++        Date = 7,
++        Decimal = 14,
++        Double = 5,
++        Empty = 0,
++        Error = 10,
++        Integer = 3,
++        Long = 20,
++        Null = 1,
++        Object = 9,
++        Short = 2,
++        Single = 4,
++        String = 8,
++        UserDefinedType = 36,
++        Variant = 12,
++    }
++    public sealed class VBFixedArrayAttribute : Attribute {
++        public VBFixedArrayAttribute(int UpperBound1);
++        public VBFixedArrayAttribute(int UpperBound1, int UpperBound2);
++        public int[] Bounds { get; }
++        public int Length { get; }
++    }
++    public sealed class VBFixedStringAttribute : Attribute {
++        public VBFixedStringAttribute(int Length);
++        public int Length { get; }
++    }
++    public sealed class VBMath {
++        public static void Randomize();
++        public static void Randomize(double Number);
++        public static float Rnd();
++        public static float Rnd(float Number);
++    }
++    public enum VbStrConv {
++        Hiragana = 32,
++        Katakana = 16,
++        LinguisticCasing = 1024,
++        Lowercase = 2,
++        Narrow = 8,
++        None = 0,
++        ProperCase = 3,
++        SimplifiedChinese = 256,
++        TraditionalChinese = 512,
++        Uppercase = 1,
++        Wide = 4,
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Buffers.md

@@ -0,0 +1,67 @@
+# System.Buffers
+
+``` diff
+ namespace System.Buffers {
++    public sealed class ArrayBufferWriter<T> : IBufferWriter<T> {
++        public ArrayBufferWriter();
++        public ArrayBufferWriter(int initialCapacity);
++        public int Capacity { get; }
++        public int FreeCapacity { get; }
++        public int WrittenCount { get; }
++        public ReadOnlyMemory<T> WrittenMemory { get; }
++        public ReadOnlySpan<T> WrittenSpan { get; }
++        public void Advance(int count);
++        public void Clear();
++        public Memory<T> GetMemory(int sizeHint = 0);
++        public Span<T> GetSpan(int sizeHint = 0);
++    }
+     public readonly struct ReadOnlySequence<T> {
++        public ReadOnlySpan<T> FirstSpan { get; }
+     }
++    public ref struct SequenceReader<T> where T : struct, IEquatable<T> {
++        public SequenceReader(ReadOnlySequence<T> sequence);
++        public long Consumed { get; }
++        public ReadOnlySpan<T> CurrentSpan { get; }
++        public int CurrentSpanIndex { get; }
++        public bool End { get; }
++        public long Length { get; }
++        public SequencePosition Position { get; }
++        public long Remaining { get; }
++        public ReadOnlySequence<T> Sequence { get; }
++        public ReadOnlySpan<T> UnreadSpan { get; }
++        public void Advance(long count);
++        public long AdvancePast(T value);
++        public long AdvancePastAny(ReadOnlySpan<T> values);
++        public long AdvancePastAny(T value0, T value1);
++        public long AdvancePastAny(T value0, T value1, T value2);
++        public long AdvancePastAny(T value0, T value1, T value2, T value3);
++        public bool IsNext(ReadOnlySpan<T> next, bool advancePast = false);
++        public bool IsNext(T next, bool advancePast = false);
++        public void Rewind(long count);
++        public bool TryAdvanceTo(T delimiter, bool advancePastDelimiter = true);
++        public bool TryAdvanceToAny(ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++        public bool TryCopyTo(Span<T> destination);
++        public bool TryPeek(out T value);
++        public bool TryRead(out T value);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, T delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySequence<T> sequence, T delimiter, T delimiterEscape, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySpan<T> span, T delimiter, bool advancePastDelimiter = true);
++        public bool TryReadTo(out ReadOnlySpan<T> span, T delimiter, T delimiterEscape, bool advancePastDelimiter = true);
++        public bool TryReadToAny(out ReadOnlySequence<T> sequence, ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++        public bool TryReadToAny(out ReadOnlySpan<T> span, ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true);
++    }
++    public static class SequenceReaderExtensions {
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out short value);
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out int value);
++        public static bool TryReadBigEndian(this ref SequenceReader<byte> reader, out long value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out short value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out int value);
++        public static bool TryReadLittleEndian(this ref SequenceReader<byte> reader, out long value);
++    }
+     public readonly struct StandardFormat : IEquatable<StandardFormat> {
++        public static bool TryParse(ReadOnlySpan<char> format, out StandardFormat result);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Collections.Generic.md

@@ -0,0 +1,14 @@
+# System.Collections.Generic
+
+``` diff
+ namespace System.Collections.Generic {
++    public interface IAsyncEnumerable<out T> {
++        IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public interface IAsyncEnumerator<out T> : IAsyncDisposable {
++        T Current { get; }
++        ValueTask<bool> MoveNextAsync();
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Collections.Immutable.md

@@ -0,0 +1,29 @@
+# System.Collections.Immutable
+
+``` diff
+ namespace System.Collections.Immutable {
+     public static class ImmutableArray {
++        public static ImmutableArray<TSource> ToImmutableArray<TSource>(this ImmutableArray<TSource>.Builder builder);
+     }
+     public struct ImmutableArray<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IEquatable<ImmutableArray<T>>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable {
++        public ReadOnlyMemory<T> AsMemory();
++        public ReadOnlySpan<T> AsSpan();
+     }
+     public static class ImmutableDictionary {
++        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue>.Builder builder);
+     }
+     public static class ImmutableHashSet {
++        public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this ImmutableHashSet<TSource>.Builder builder);
+     }
+     public static class ImmutableList {
++        public static ImmutableList<TSource> ToImmutableList<TSource>(this ImmutableList<TSource>.Builder builder);
+     }
+     public static class ImmutableSortedDictionary {
++        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder builder);
+     }
+     public static class ImmutableSortedSet {
++        public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this ImmutableSortedSet<TSource>.Builder builder);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.ComponentModel.DataAnnotations.md

@@ -0,0 +1,16 @@
+# System.ComponentModel.DataAnnotations
+
+``` diff
+ namespace System.ComponentModel.DataAnnotations {
++    public class AssociatedMetadataTypeTypeDescriptionProvider : TypeDescriptionProvider {
++        public AssociatedMetadataTypeTypeDescriptionProvider(Type type);
++        public AssociatedMetadataTypeTypeDescriptionProvider(Type type, Type associatedMetadataType);
++        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance);
++    }
++    public sealed class MetadataTypeAttribute : Attribute {
++        public MetadataTypeAttribute(Type metadataClassType);
++        public Type MetadataClassType { get; }
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.ComponentModel.md

@@ -0,0 +1,25 @@
+# System.ComponentModel
+
+``` diff
+ namespace System.ComponentModel {
+     public class BackgroundWorker : Component {
++        protected override void Dispose(bool disposing);
+     }
+     public abstract class BaseNumberConverter : TypeConverter {
+-        protected BaseNumberConverter();
+
+     }
++    public class VersionConverter : TypeConverter {
++        public VersionConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override bool IsValid(ITypeDescriptorContext context, object value);
++    }
+     public class Win32Exception : ExternalException, ISerializable {
++        public override string ToString();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Data.Common.md

@@ -0,0 +1,36 @@
+# System.Data.Common
+
+``` diff
+ namespace System.Data.Common {
+-    public abstract class DbCommand : Component, IDbCommand, IDisposable {
++    public abstract class DbCommand : Component, IAsyncDisposable, IDbCommand, IDisposable {
++        public virtual ValueTask DisposeAsync();
++        public virtual Task PrepareAsync(CancellationToken cancellationToken = default(CancellationToken));
+     }
+-    public abstract class DbConnection : Component, IDbConnection, IDisposable {
++    public abstract class DbConnection : Component, IAsyncDisposable, IDbConnection, IDisposable {
++        protected virtual ValueTask<DbTransaction> BeginDbTransactionAsync(IsolationLevel isolationLevel, CancellationToken cancellationToken);
++        public ValueTask<DbTransaction> BeginTransactionAsync(IsolationLevel isolationLevel, CancellationToken cancellationToken = default(CancellationToken));
++        public ValueTask<DbTransaction> BeginTransactionAsync(CancellationToken cancellationToken = default(CancellationToken));
++        public virtual Task ChangeDatabaseAsync(string databaseName, CancellationToken cancellationToken = default(CancellationToken));
++        public virtual Task CloseAsync();
++        public virtual ValueTask DisposeAsync();
+     }
+-    public abstract class DbDataReader : MarshalByRefObject, IDataReader, IDataRecord, IDisposable, IEnumerable {
++    public abstract class DbDataReader : MarshalByRefObject, IAsyncDisposable, IDataReader, IDataRecord, IDisposable, IEnumerable {
++        public virtual Task CloseAsync();
++        public virtual ValueTask DisposeAsync();
+     }
+     public abstract class DbProviderFactory {
++        public virtual bool CanCreateCommandBuilder { get; }
++        public virtual bool CanCreateDataAdapter { get; }
+     }
+-    public abstract class DbTransaction : MarshalByRefObject, IDbTransaction, IDisposable {
++    public abstract class DbTransaction : MarshalByRefObject, IAsyncDisposable, IDbTransaction, IDisposable {
++        public virtual Task CommitAsync(CancellationToken cancellationToken = default(CancellationToken));
++        public virtual ValueTask DisposeAsync();
++        public virtual Task RollbackAsync(CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Data.md

@@ -0,0 +1,104 @@
+# System.Data
+
+``` diff
+ namespace System.Data {
+     public abstract class Constraint {
+-        protected Constraint();
+
+     }
++    public static class DataReaderExtensions {
++        public static bool GetBoolean(this DbDataReader reader, string name);
++        public static byte GetByte(this DbDataReader reader, string name);
++        public static long GetBytes(this DbDataReader reader, string name, long dataOffset, byte[] buffer, int bufferOffset, int length);
++        public static char GetChar(this DbDataReader reader, string name);
++        public static long GetChars(this DbDataReader reader, string name, long dataOffset, char[] buffer, int bufferOffset, int length);
++        public static DbDataReader GetData(this DbDataReader reader, string name);
++        public static string GetDataTypeName(this DbDataReader reader, string name);
++        public static DateTime GetDateTime(this DbDataReader reader, string name);
++        public static decimal GetDecimal(this DbDataReader reader, string name);
++        public static double GetDouble(this DbDataReader reader, string name);
++        public static Type GetFieldType(this DbDataReader reader, string name);
++        public static T GetFieldValue<T>(this DbDataReader reader, string name);
++        public static Task<T> GetFieldValueAsync<T>(this DbDataReader reader, string name, CancellationToken cancellationToken = default(CancellationToken));
++        public static float GetFloat(this DbDataReader reader, string name);
++        public static Guid GetGuid(this DbDataReader reader, string name);
++        public static short GetInt16(this DbDataReader reader, string name);
++        public static int GetInt32(this DbDataReader reader, string name);
++        public static long GetInt64(this DbDataReader reader, string name);
++        public static Type GetProviderSpecificFieldType(this DbDataReader reader, string name);
++        public static object GetProviderSpecificValue(this DbDataReader reader, string name);
++        public static Stream GetStream(this DbDataReader reader, string name);
++        public static string GetString(this DbDataReader reader, string name);
++        public static TextReader GetTextReader(this DbDataReader reader, string name);
++        public static object GetValue(this DbDataReader reader, string name);
++        public static bool IsDBNull(this DbDataReader reader, string name);
++        public static Task<bool> IsDBNullAsync(this DbDataReader reader, string name, CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public static class DataRowComparer {
++        public static DataRowComparer<DataRow> Default { get; }
++    }
++    public sealed class DataRowComparer<TRow> : IEqualityComparer<TRow> where TRow : DataRow {
++        public static DataRowComparer<TRow> Default { get; }
++        public bool Equals(TRow leftRow, TRow rightRow);
++        public int GetHashCode(TRow row);
++    }
++    public static class DataRowExtensions {
++        public static T Field<T>(this DataRow row, DataColumn column);
++        public static T Field<T>(this DataRow row, DataColumn column, DataRowVersion version);
++        public static T Field<T>(this DataRow row, int columnIndex);
++        public static T Field<T>(this DataRow row, int columnIndex, DataRowVersion version);
++        public static T Field<T>(this DataRow row, string columnName);
++        public static T Field<T>(this DataRow row, string columnName, DataRowVersion version);
++        public static void SetField<T>(this DataRow row, DataColumn column, T value);
++        public static void SetField<T>(this DataRow row, int columnIndex, T value);
++        public static void SetField<T>(this DataRow row, string columnName, T value);
++    }
++    public static class DataTableExtensions {
++        public static DataView AsDataView(this DataTable table);
++        public static DataView AsDataView<T>(this EnumerableRowCollection<T> source) where T : DataRow;
++        public static EnumerableRowCollection<DataRow> AsEnumerable(this DataTable source);
++        public static DataTable CopyToDataTable<T>(this IEnumerable<T> source) where T : DataRow;
++        public static void CopyToDataTable<T>(this IEnumerable<T> source, DataTable table, LoadOption options) where T : DataRow;
++        public static void CopyToDataTable<T>(this IEnumerable<T> source, DataTable table, LoadOption options, FillErrorEventHandler errorHandler) where T : DataRow;
++    }
++    public abstract class EnumerableRowCollection : IEnumerable {
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++    }
++    public class EnumerableRowCollection<TRow> : EnumerableRowCollection, IEnumerable, IEnumerable<TRow> {
++        public IEnumerator<TRow> GetEnumerator();
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++    }
++    public static class EnumerableRowCollectionExtensions {
++        public static EnumerableRowCollection<TResult> Cast<TResult>(this EnumerableRowCollection source);
++        public static OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this EnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector);
++        public static OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this EnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer);
++        public static OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this EnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector);
++        public static OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this EnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer);
++        public static EnumerableRowCollection<S> Select<TRow, S>(this EnumerableRowCollection<TRow> source, Func<TRow, S> selector);
++        public static OrderedEnumerableRowCollection<TRow> ThenBy<TRow, TKey>(this OrderedEnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector);
++        public static OrderedEnumerableRowCollection<TRow> ThenBy<TRow, TKey>(this OrderedEnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer);
++        public static OrderedEnumerableRowCollection<TRow> ThenByDescending<TRow, TKey>(this OrderedEnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector);
++        public static OrderedEnumerableRowCollection<TRow> ThenByDescending<TRow, TKey>(this OrderedEnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer);
++        public static EnumerableRowCollection<TRow> Where<TRow>(this EnumerableRowCollection<TRow> source, Func<TRow, bool> predicate);
++    }
++    public sealed class OrderedEnumerableRowCollection<TRow> : EnumerableRowCollection<TRow>
++    public abstract class TypedTableBase<T> : DataTable, IEnumerable, IEnumerable<T> where T : DataRow {
++        protected TypedTableBase();
++        protected TypedTableBase(SerializationInfo info, StreamingContext context);
++        public EnumerableRowCollection<TResult> Cast<TResult>();
++        public IEnumerator<T> GetEnumerator();
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++    }
++    public static class TypedTableBaseExtensions {
++        public static EnumerableRowCollection<TRow> AsEnumerable<TRow>(this TypedTableBase<TRow> source) where TRow : DataRow;
++        public static TRow ElementAtOrDefault<TRow>(this TypedTableBase<TRow> source, int index) where TRow : DataRow;
++        public static OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this TypedTableBase<TRow> source, Func<TRow, TKey> keySelector) where TRow : DataRow;
++        public static OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this TypedTableBase<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer) where TRow : DataRow;
++        public static OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this TypedTableBase<TRow> source, Func<TRow, TKey> keySelector) where TRow : DataRow;
++        public static OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this TypedTableBase<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer) where TRow : DataRow;
++        public static EnumerableRowCollection<S> Select<TRow, S>(this TypedTableBase<TRow> source, Func<TRow, S> selector) where TRow : DataRow;
++        public static EnumerableRowCollection<TRow> Where<TRow>(this TypedTableBase<TRow> source, Func<TRow, bool> predicate) where TRow : DataRow;
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Diagnostics.CodeAnalysis.md

@@ -0,0 +1,38 @@
+# System.Diagnostics.CodeAnalysis
+
+``` diff
+ namespace System.Diagnostics.CodeAnalysis {
++    public sealed class AllowNullAttribute : Attribute {
++        public AllowNullAttribute();
++    }
++    public sealed class DisallowNullAttribute : Attribute {
++        public DisallowNullAttribute();
++    }
++    public sealed class DoesNotReturnAttribute : Attribute {
++        public DoesNotReturnAttribute();
++    }
++    public sealed class DoesNotReturnIfAttribute : Attribute {
++        public DoesNotReturnIfAttribute(bool parameterValue);
++        public bool ParameterValue { get; }
++    }
++    public sealed class MaybeNullAttribute : Attribute {
++        public MaybeNullAttribute();
++    }
++    public sealed class MaybeNullWhenAttribute : Attribute {
++        public MaybeNullWhenAttribute(bool returnValue);
++        public bool ReturnValue { get; }
++    }
++    public sealed class NotNullAttribute : Attribute {
++        public NotNullAttribute();
++    }
++    public sealed class NotNullIfNotNullAttribute : Attribute {
++        public NotNullIfNotNullAttribute(string parameterName);
++        public string ParameterName { get; }
++    }
++    public sealed class NotNullWhenAttribute : Attribute {
++        public NotNullWhenAttribute(bool returnValue);
++        public bool ReturnValue { get; }
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Diagnostics.Tracing.md

@@ -0,0 +1,37 @@
+# System.Diagnostics.Tracing
+
+``` diff
+ namespace System.Diagnostics.Tracing {
++    public abstract class DiagnosticCounter : IDisposable {
++        public string DisplayName { get; set; }
++        public string DisplayUnits { get; set; }
++        public EventSource EventSource { get; }
++        public string Name { get; }
++        public void AddMetadata(string key, string value);
++        public void Dispose();
++    }
+-    public class EventCounter : IDisposable {
++    public class EventCounter : DiagnosticCounter {
+-        public void Dispose();
+
++        public override string ToString();
++        public void WriteMetric(double value);
+     }
++    public class IncrementingEventCounter : DiagnosticCounter {
++        public IncrementingEventCounter(string name, EventSource eventSource);
++        public TimeSpan DisplayRateTimeScale { get; set; }
++        public void Increment(double increment = 1);
++        public override string ToString();
++    }
++    public class IncrementingPollingCounter : DiagnosticCounter {
++        public IncrementingPollingCounter(string name, EventSource eventSource, Func<double> totalValueProvider);
++        public TimeSpan DisplayRateTimeScale { get; set; }
++        public override string ToString();
++    }
++    public class PollingCounter : DiagnosticCounter {
++        public PollingCounter(string name, EventSource eventSource, Func<double> metricProvider);
++        public override string ToString();
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Diagnostics.md

@@ -0,0 +1,96 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public class Activity {
++        public ActivityTraceFlags ActivityTraceFlags { get; set; }
+-        public static Activity Current { get; private set; }
++        public static Activity Current { get; set; }
++        public static ActivityIdFormat DefaultIdFormat { get; set; }
++        public static bool ForceDefaultIdFormat { get; set; }
++        public ActivityIdFormat IdFormat { get; }
++        public ActivitySpanId ParentSpanId { get; }
++        public bool Recorded { get; }
++        public ActivitySpanId SpanId { get; }
++        public ActivityTraceId TraceId { get; }
++        public string TraceStateString { get; set; }
++        public Activity SetIdFormat(ActivityIdFormat format);
++        public Activity SetParentId(ActivityTraceId traceId, ActivitySpanId spanId, ActivityTraceFlags activityTraceFlags = ActivityTraceFlags.None);
+     }
++    public enum ActivityIdFormat {
++        Hierarchical = 1,
++        Unknown = 0,
++        W3C = 2,
++    }
++    public readonly struct ActivitySpanId : IEquatable<ActivitySpanId> {
++        public void CopyTo(Span<byte> destination);
++        public static ActivitySpanId CreateFromBytes(ReadOnlySpan<byte> idData);
++        public static ActivitySpanId CreateFromString(ReadOnlySpan<char> idData);
++        public static ActivitySpanId CreateFromUtf8String(ReadOnlySpan<byte> idData);
++        public static ActivitySpanId CreateRandom();
++        public bool Equals(ActivitySpanId spanId);
++        public override bool Equals(object obj);
++        public override int GetHashCode();
++        public static bool operator ==(ActivitySpanId spanId1, ActivitySpanId spandId2);
++        public static bool operator !=(ActivitySpanId spanId1, ActivitySpanId spandId2);
++        public string ToHexString();
++        public override string ToString();
++    }
++    public enum ActivityTraceFlags {
++        None = 0,
++        Recorded = 1,
++    }
++    public readonly struct ActivityTraceId : IEquatable<ActivityTraceId> {
++        public void CopyTo(Span<byte> destination);
++        public static ActivityTraceId CreateFromBytes(ReadOnlySpan<byte> idData);
++        public static ActivityTraceId CreateFromString(ReadOnlySpan<char> idData);
++        public static ActivityTraceId CreateFromUtf8String(ReadOnlySpan<byte> idData);
++        public static ActivityTraceId CreateRandom();
++        public bool Equals(ActivityTraceId traceId);
++        public override bool Equals(object obj);
++        public override int GetHashCode();
++        public static bool operator ==(ActivityTraceId traceId1, ActivityTraceId traceId2);
++        public static bool operator !=(ActivityTraceId traceId1, ActivityTraceId traceId2);
++        public string ToHexString();
++        public override string ToString();
++    }
++    public class ConsoleTraceListener : TextWriterTraceListener {
++        public ConsoleTraceListener();
++        public ConsoleTraceListener(bool useErrorStream);
++        public override void Close();
++    }
+     public class DiagnosticListener : DiagnosticSource, IDisposable, IObservable<KeyValuePair<string, object>> {
++        public override void OnActivityExport(Activity activity, object payload);
++        public override void OnActivityImport(Activity activity, object payload);
++        public virtual IDisposable Subscribe(IObserver<KeyValuePair<string, object>> observer, Func<string, object, object, bool> isEnabled, Action<Activity, object> onActivityImport = null, Action<Activity, object> onActivityExport = null);
++        public override string ToString();
+-        public override void Write(string name, object parameters);
++        public override void Write(string name, object value);
+     }
+     public abstract class DiagnosticSource {
++        public virtual void OnActivityExport(Activity activity, object payload);
++        public virtual void OnActivityImport(Activity activity, object payload);
+     }
+     public class Process : Component {
++        public void Kill(bool entireProcessTree);
+     }
++    public class XmlWriterTraceListener : TextWriterTraceListener {
++        public XmlWriterTraceListener(Stream stream);
++        public XmlWriterTraceListener(Stream stream, string name);
++        public XmlWriterTraceListener(TextWriter writer);
++        public XmlWriterTraceListener(TextWriter writer, string name);
++        public XmlWriterTraceListener(string filename);
++        public XmlWriterTraceListener(string filename, string name);
++        public override void Close();
++        public override void Fail(string message, string detailMessage);
++        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data);
++        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data);
++        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message);
++        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args);
++        public override void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId);
++        public override void Write(string message);
++        public override void WriteLine(string message);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Drawing.md

@@ -0,0 +1,50 @@
+# System.Drawing
+
+``` diff
+ namespace System.Drawing {
++    public static class ColorTranslator {
++        public static Color FromHtml(string htmlColor);
++        public static Color FromOle(int oleColor);
++        public static Color FromWin32(int win32Color);
++        public static string ToHtml(Color c);
++        public static int ToOle(Color c);
++        public static int ToWin32(Color c);
++    }
++    public static class SystemColors {
++        public static Color ActiveBorder { get; }
++        public static Color ActiveCaption { get; }
++        public static Color ActiveCaptionText { get; }
++        public static Color AppWorkspace { get; }
++        public static Color ButtonFace { get; }
++        public static Color ButtonHighlight { get; }
++        public static Color ButtonShadow { get; }
++        public static Color Control { get; }
++        public static Color ControlDark { get; }
++        public static Color ControlDarkDark { get; }
++        public static Color ControlLight { get; }
++        public static Color ControlLightLight { get; }
++        public static Color ControlText { get; }
++        public static Color Desktop { get; }
++        public static Color GradientActiveCaption { get; }
++        public static Color GradientInactiveCaption { get; }
++        public static Color GrayText { get; }
++        public static Color Highlight { get; }
++        public static Color HighlightText { get; }
++        public static Color HotTrack { get; }
++        public static Color InactiveBorder { get; }
++        public static Color InactiveCaption { get; }
++        public static Color InactiveCaptionText { get; }
++        public static Color Info { get; }
++        public static Color InfoText { get; }
++        public static Color Menu { get; }
++        public static Color MenuBar { get; }
++        public static Color MenuHighlight { get; }
++        public static Color MenuText { get; }
++        public static Color ScrollBar { get; }
++        public static Color Window { get; }
++        public static Color WindowFrame { get; }
++        public static Color WindowText { get; }
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Globalization.md

@@ -0,0 +1,18 @@
+# System.Globalization
+
+``` diff
+ namespace System.Globalization {
+     public class CompareInfo : IDeserializationCallback {
++        public int GetHashCode(ReadOnlySpan<char> source, CompareOptions options);
+     }
++    public static class ISOWeek {
++        public static int GetWeekOfYear(DateTime date);
++        public static int GetWeeksInYear(int year);
++        public static int GetYear(DateTime date);
++        public static DateTime GetYearEnd(int year);
++        public static DateTime GetYearStart(int year);
++        public static DateTime ToDateTime(int year, int week, DayOfWeek dayOfWeek);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.IO.Compression.md

@@ -0,0 +1,37 @@
+# System.IO.Compression
+
+``` diff
+ namespace System.IO.Compression {
+     public sealed class BrotliStream : Stream {
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class DeflateStream : Stream {
++        public override void CopyTo(Stream destination, int bufferSize);
++        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class GZipStream : Stream {
++        public override void CopyTo(Stream destination, int bufferSize);
++        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.IO.IsolatedStorage.md

@@ -0,0 +1,17 @@
+# System.IO.IsolatedStorage
+
+``` diff
+ namespace System.IO.IsolatedStorage {
+     public class IsolatedStorageFileStream : FileStream {
++        public override ValueTask DisposeAsync();
++        public override Task FlushAsync(CancellationToken cancellationToken);
++        public override int Read(Span<byte> buffer);
++        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.IO.Pipes.md

@@ -0,0 +1,13 @@
+# System.IO.Pipes
+
+``` diff
+ namespace System.IO.Pipes {
+     public abstract class PipeStream : Stream {
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.IO.md

@@ -0,0 +1,90 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+-    public class BinaryWriter : IDisposable {
++    public class BinaryWriter : IAsyncDisposable, IDisposable {
++        public virtual ValueTask DisposeAsync();
+     }
+     public sealed class BufferedStream : Stream {
++        public override void CopyTo(Stream destination, int bufferSize);
++        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
++        public override ValueTask DisposeAsync();
++        public override int Read(Span<byte> destination);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public static class File {
++        public static void Move(string sourceFileName, string destFileName, bool overwrite);
+     }
+     public sealed class FileInfo : FileSystemInfo {
++        public void MoveTo(string destFileName, bool overwrite);
+     }
+     public class FileStream : Stream {
++        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
++        public override ValueTask DisposeAsync();
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public abstract class FileSystemInfo : MarshalByRefObject, ISerializable {
++        public override string ToString();
+     }
+     public class FileSystemWatcher : Component, ISupportInitialize {
++        public Collection<string> Filters { get; }
+     }
+     public static class Path {
++        public static bool EndsInDirectorySeparator(ReadOnlySpan<char> path);
++        public static bool EndsInDirectorySeparator(string path);
++        public static string Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, ReadOnlySpan<char> path4);
++        public static string Join(string path1, string path2);
++        public static string Join(string path1, string path2, string path3);
++        public static string Join(string path1, string path2, string path3, string path4);
++        public static string Join(params string[] paths);
++        public static ReadOnlySpan<char> TrimEndingDirectorySeparator(ReadOnlySpan<char> path);
++        public static string TrimEndingDirectorySeparator(string path);
+     }
+-    public abstract class Stream : MarshalByRefObject, IDisposable {
++    public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable {
++        public virtual ValueTask DisposeAsync();
+     }
+     public class StreamReader : TextReader {
+-        public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen);
++        public StreamReader(Stream stream, Encoding encoding = null, bool detectEncodingFromByteOrderMarks = true, int bufferSize = -1, bool leaveOpen = false);
+     }
+     public class StreamWriter : TextWriter {
+-        public StreamWriter(Stream stream, Encoding encoding, int bufferSize, bool leaveOpen);
++        public StreamWriter(Stream stream, Encoding encoding = null, int bufferSize = -1, bool leaveOpen = false);
++        public override ValueTask DisposeAsync();
++        public override void Write(string format, object arg0);
++        public override void Write(string format, object arg0, object arg1);
++        public override void Write(string format, object arg0, object arg1, object arg2);
++        public override void Write(string format, params object[] arg);
++        public override void WriteLine(string format, object arg0);
++        public override void WriteLine(string format, object arg0, object arg1);
++        public override void WriteLine(string format, object arg0, object arg1, object arg2);
++        public override void WriteLine(string format, params object[] arg);
+     }
+     public class StringWriter : TextWriter {
++        public override void Write(StringBuilder value);
++        public override Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
++        public override void WriteLine(StringBuilder value);
++        public override Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
+     }
+-    public abstract class TextWriter : MarshalByRefObject, IDisposable {
++    public abstract class TextWriter : MarshalByRefObject, IAsyncDisposable, IDisposable {
++        public virtual ValueTask DisposeAsync();
++        public virtual void Write(StringBuilder value);
++        public virtual Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
++        public virtual void WriteLine(StringBuilder value);
++        public virtual Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class UnmanagedMemoryStream : Stream {
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Linq.md

@@ -0,0 +1,21 @@
+# System.Linq
+
+``` diff
+ namespace System.Linq {
+     public static class Enumerable {
++        public static IEnumerable<ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second);
+     }
+     public abstract class EnumerableExecutor {
+-        protected EnumerableExecutor();
+
+     }
+     public abstract class EnumerableQuery {
+-        protected EnumerableQuery();
+
+     }
+     public static class Queryable {
++        public static IQueryable<ValueTuple<TFirst, TSecond>> Zip<TFirst, TSecond>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Net.Http.md

@@ -0,0 +1,20 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
+     public class HttpClient : HttpMessageInvoker {
++        public static IWebProxy DefaultProxy { get; set; }
++        public Version DefaultRequestVersion { get; set; }
+     }
+     public class HttpResponseMessage : IDisposable {
++        public HttpResponseHeaders TrailingHeaders { get; }
+     }
+     public class MultipartContent : HttpContent, IEnumerable, IEnumerable<HttpContent> {
++        protected override Task<Stream> CreateContentReadStreamAsync();
+     }
+     public sealed class ReadOnlyMemoryContent : HttpContent {
++        protected override Task<Stream> CreateContentReadStreamAsync();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Net.Security.md

@@ -0,0 +1,375 @@
+# System.Net.Security
+
+``` diff
+ namespace System.Net.Security {
+     public abstract class AuthenticatedStream : Stream {
++        public override ValueTask DisposeAsync();
+     }
++    public sealed class CipherSuitesPolicy {
++        public CipherSuitesPolicy(IEnumerable<TlsCipherSuite> allowedCipherSuites);
++        public IEnumerable<TlsCipherSuite> AllowedCipherSuites { get; }
++    }
+     public class NegotiateStream : AuthenticatedStream {
++        public override ValueTask DisposeAsync();
+     }
+     public class SslClientAuthenticationOptions {
++        public CipherSuitesPolicy CipherSuitesPolicy { get; set; }
+     }
+     public class SslServerAuthenticationOptions {
++        public CipherSuitesPolicy CipherSuitesPolicy { get; set; }
+     }
+     public class SslStream : AuthenticatedStream {
++        public virtual TlsCipherSuite NegotiatedCipherSuite { get; }
+-        public Task AuthenticateAsClientAsync(SslClientAuthenticationOptions sslClientAuthenticationOptions, CancellationToken cancellationToken);
++        public Task AuthenticateAsClientAsync(SslClientAuthenticationOptions sslClientAuthenticationOptions, CancellationToken cancellationToken = default(CancellationToken));
+-        public Task AuthenticateAsServerAsync(SslServerAuthenticationOptions sslServerAuthenticationOptions, CancellationToken cancellationToken);
++        public Task AuthenticateAsServerAsync(SslServerAuthenticationOptions sslServerAuthenticationOptions, CancellationToken cancellationToken = default(CancellationToken));
++        public override ValueTask DisposeAsync();
++        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
++    public enum TlsCipherSuite : ushort {
++        TLS_AES_128_CCM_8_SHA256 = (ushort)4869,
++        TLS_AES_128_CCM_SHA256 = (ushort)4868,
++        TLS_AES_128_GCM_SHA256 = (ushort)4865,
++        TLS_AES_256_GCM_SHA384 = (ushort)4866,
++        TLS_CHACHA20_POLY1305_SHA256 = (ushort)4867,
++        TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA = (ushort)17,
++        TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA = (ushort)19,
++        TLS_DHE_DSS_WITH_AES_128_CBC_SHA = (ushort)50,
++        TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 = (ushort)64,
++        TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 = (ushort)162,
++        TLS_DHE_DSS_WITH_AES_256_CBC_SHA = (ushort)56,
++        TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 = (ushort)106,
++        TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 = (ushort)163,
++        TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256 = (ushort)49218,
++        TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256 = (ushort)49238,
++        TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384 = (ushort)49219,
++        TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384 = (ushort)49239,
++        TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA = (ushort)68,
++        TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)189,
++        TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49280,
++        TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA = (ushort)135,
++        TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 = (ushort)195,
++        TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49281,
++        TLS_DHE_DSS_WITH_DES_CBC_SHA = (ushort)18,
++        TLS_DHE_DSS_WITH_SEED_CBC_SHA = (ushort)153,
++        TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA = (ushort)143,
++        TLS_DHE_PSK_WITH_AES_128_CBC_SHA = (ushort)144,
++        TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 = (ushort)178,
++        TLS_DHE_PSK_WITH_AES_128_CCM = (ushort)49318,
++        TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 = (ushort)170,
++        TLS_DHE_PSK_WITH_AES_256_CBC_SHA = (ushort)145,
++        TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 = (ushort)179,
++        TLS_DHE_PSK_WITH_AES_256_CCM = (ushort)49319,
++        TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 = (ushort)171,
++        TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 = (ushort)49254,
++        TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 = (ushort)49260,
++        TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 = (ushort)49255,
++        TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 = (ushort)49261,
++        TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)49302,
++        TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49296,
++        TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 = (ushort)49303,
++        TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49297,
++        TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 = (ushort)52397,
++        TLS_DHE_PSK_WITH_NULL_SHA = (ushort)45,
++        TLS_DHE_PSK_WITH_NULL_SHA256 = (ushort)180,
++        TLS_DHE_PSK_WITH_NULL_SHA384 = (ushort)181,
++        TLS_DHE_PSK_WITH_RC4_128_SHA = (ushort)142,
++        TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA = (ushort)20,
++        TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA = (ushort)22,
++        TLS_DHE_RSA_WITH_AES_128_CBC_SHA = (ushort)51,
++        TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = (ushort)103,
++        TLS_DHE_RSA_WITH_AES_128_CCM = (ushort)49310,
++        TLS_DHE_RSA_WITH_AES_128_CCM_8 = (ushort)49314,
++        TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = (ushort)158,
++        TLS_DHE_RSA_WITH_AES_256_CBC_SHA = (ushort)57,
++        TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = (ushort)107,
++        TLS_DHE_RSA_WITH_AES_256_CCM = (ushort)49311,
++        TLS_DHE_RSA_WITH_AES_256_CCM_8 = (ushort)49315,
++        TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = (ushort)159,
++        TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 = (ushort)49220,
++        TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 = (ushort)49234,
++        TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 = (ushort)49221,
++        TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 = (ushort)49235,
++        TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA = (ushort)69,
++        TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)190,
++        TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49276,
++        TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA = (ushort)136,
++        TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 = (ushort)196,
++        TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49277,
++        TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = (ushort)52394,
++        TLS_DHE_RSA_WITH_DES_CBC_SHA = (ushort)21,
++        TLS_DHE_RSA_WITH_SEED_CBC_SHA = (ushort)154,
++        TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA = (ushort)25,
++        TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 = (ushort)23,
++        TLS_DH_anon_WITH_3DES_EDE_CBC_SHA = (ushort)27,
++        TLS_DH_anon_WITH_AES_128_CBC_SHA = (ushort)52,
++        TLS_DH_anon_WITH_AES_128_CBC_SHA256 = (ushort)108,
++        TLS_DH_anon_WITH_AES_128_GCM_SHA256 = (ushort)166,
++        TLS_DH_anon_WITH_AES_256_CBC_SHA = (ushort)58,
++        TLS_DH_anon_WITH_AES_256_CBC_SHA256 = (ushort)109,
++        TLS_DH_anon_WITH_AES_256_GCM_SHA384 = (ushort)167,
++        TLS_DH_anon_WITH_ARIA_128_CBC_SHA256 = (ushort)49222,
++        TLS_DH_anon_WITH_ARIA_128_GCM_SHA256 = (ushort)49242,
++        TLS_DH_anon_WITH_ARIA_256_CBC_SHA384 = (ushort)49223,
++        TLS_DH_anon_WITH_ARIA_256_GCM_SHA384 = (ushort)49243,
++        TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA = (ushort)70,
++        TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)191,
++        TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49284,
++        TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA = (ushort)137,
++        TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256 = (ushort)197,
++        TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49285,
++        TLS_DH_anon_WITH_DES_CBC_SHA = (ushort)26,
++        TLS_DH_anon_WITH_RC4_128_MD5 = (ushort)24,
++        TLS_DH_anon_WITH_SEED_CBC_SHA = (ushort)155,
++        TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA = (ushort)11,
++        TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA = (ushort)13,
++        TLS_DH_DSS_WITH_AES_128_CBC_SHA = (ushort)48,
++        TLS_DH_DSS_WITH_AES_128_CBC_SHA256 = (ushort)62,
++        TLS_DH_DSS_WITH_AES_128_GCM_SHA256 = (ushort)164,
++        TLS_DH_DSS_WITH_AES_256_CBC_SHA = (ushort)54,
++        TLS_DH_DSS_WITH_AES_256_CBC_SHA256 = (ushort)104,
++        TLS_DH_DSS_WITH_AES_256_GCM_SHA384 = (ushort)165,
++        TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256 = (ushort)49214,
++        TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256 = (ushort)49240,
++        TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384 = (ushort)49215,
++        TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384 = (ushort)49241,
++        TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA = (ushort)66,
++        TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)187,
++        TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49282,
++        TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA = (ushort)133,
++        TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 = (ushort)193,
++        TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49283,
++        TLS_DH_DSS_WITH_DES_CBC_SHA = (ushort)12,
++        TLS_DH_DSS_WITH_SEED_CBC_SHA = (ushort)151,
++        TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA = (ushort)14,
++        TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA = (ushort)16,
++        TLS_DH_RSA_WITH_AES_128_CBC_SHA = (ushort)49,
++        TLS_DH_RSA_WITH_AES_128_CBC_SHA256 = (ushort)63,
++        TLS_DH_RSA_WITH_AES_128_GCM_SHA256 = (ushort)160,
++        TLS_DH_RSA_WITH_AES_256_CBC_SHA = (ushort)55,
++        TLS_DH_RSA_WITH_AES_256_CBC_SHA256 = (ushort)105,
++        TLS_DH_RSA_WITH_AES_256_GCM_SHA384 = (ushort)161,
++        TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256 = (ushort)49216,
++        TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256 = (ushort)49236,
++        TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384 = (ushort)49217,
++        TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384 = (ushort)49237,
++        TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA = (ushort)67,
++        TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)188,
++        TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49278,
++        TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA = (ushort)134,
++        TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 = (ushort)194,
++        TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49279,
++        TLS_DH_RSA_WITH_DES_CBC_SHA = (ushort)15,
++        TLS_DH_RSA_WITH_SEED_CBC_SHA = (ushort)152,
++        TLS_ECCPWD_WITH_AES_128_CCM_SHA256 = (ushort)49330,
++        TLS_ECCPWD_WITH_AES_128_GCM_SHA256 = (ushort)49328,
++        TLS_ECCPWD_WITH_AES_256_CCM_SHA384 = (ushort)49331,
++        TLS_ECCPWD_WITH_AES_256_GCM_SHA384 = (ushort)49329,
++        TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA = (ushort)49160,
++        TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = (ushort)49161,
++        TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = (ushort)49187,
++        TLS_ECDHE_ECDSA_WITH_AES_128_CCM = (ushort)49324,
++        TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 = (ushort)49326,
++        TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = (ushort)49195,
++        TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = (ushort)49162,
++        TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = (ushort)49188,
++        TLS_ECDHE_ECDSA_WITH_AES_256_CCM = (ushort)49325,
++        TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 = (ushort)49327,
++        TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = (ushort)49196,
++        TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 = (ushort)49224,
++        TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 = (ushort)49244,
++        TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 = (ushort)49225,
++        TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 = (ushort)49245,
++        TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)49266,
++        TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49286,
++        TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 = (ushort)49267,
++        TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49287,
++        TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = (ushort)52393,
++        TLS_ECDHE_ECDSA_WITH_NULL_SHA = (ushort)49158,
++        TLS_ECDHE_ECDSA_WITH_RC4_128_SHA = (ushort)49159,
++        TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA = (ushort)49204,
++        TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA = (ushort)49205,
++        TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 = (ushort)49207,
++        TLS_ECDHE_PSK_WITH_AES_128_CCM_8_SHA256 = (ushort)53251,
++        TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256 = (ushort)53253,
++        TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256 = (ushort)53249,
++        TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA = (ushort)49206,
++        TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 = (ushort)49208,
++        TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384 = (ushort)53250,
++        TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 = (ushort)49264,
++        TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 = (ushort)49265,
++        TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)49306,
++        TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 = (ushort)49307,
++        TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 = (ushort)52396,
++        TLS_ECDHE_PSK_WITH_NULL_SHA = (ushort)49209,
++        TLS_ECDHE_PSK_WITH_NULL_SHA256 = (ushort)49210,
++        TLS_ECDHE_PSK_WITH_NULL_SHA384 = (ushort)49211,
++        TLS_ECDHE_PSK_WITH_RC4_128_SHA = (ushort)49203,
++        TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA = (ushort)49170,
++        TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = (ushort)49171,
++        TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = (ushort)49191,
++        TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = (ushort)49199,
++        TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = (ushort)49172,
++        TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = (ushort)49192,
++        TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = (ushort)49200,
++        TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 = (ushort)49228,
++        TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 = (ushort)49248,
++        TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 = (ushort)49229,
++        TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 = (ushort)49249,
++        TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)49270,
++        TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49290,
++        TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 = (ushort)49271,
++        TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49291,
++        TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = (ushort)52392,
++        TLS_ECDHE_RSA_WITH_NULL_SHA = (ushort)49168,
++        TLS_ECDHE_RSA_WITH_RC4_128_SHA = (ushort)49169,
++        TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA = (ushort)49175,
++        TLS_ECDH_anon_WITH_AES_128_CBC_SHA = (ushort)49176,
++        TLS_ECDH_anon_WITH_AES_256_CBC_SHA = (ushort)49177,
++        TLS_ECDH_anon_WITH_NULL_SHA = (ushort)49173,
++        TLS_ECDH_anon_WITH_RC4_128_SHA = (ushort)49174,
++        TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA = (ushort)49155,
++        TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = (ushort)49156,
++        TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = (ushort)49189,
++        TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = (ushort)49197,
++        TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = (ushort)49157,
++        TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = (ushort)49190,
++        TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = (ushort)49198,
++        TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 = (ushort)49226,
++        TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 = (ushort)49246,
++        TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 = (ushort)49227,
++        TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 = (ushort)49247,
++        TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)49268,
++        TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49288,
++        TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 = (ushort)49269,
++        TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49289,
++        TLS_ECDH_ECDSA_WITH_NULL_SHA = (ushort)49153,
++        TLS_ECDH_ECDSA_WITH_RC4_128_SHA = (ushort)49154,
++        TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA = (ushort)49165,
++        TLS_ECDH_RSA_WITH_AES_128_CBC_SHA = (ushort)49166,
++        TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 = (ushort)49193,
++        TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 = (ushort)49201,
++        TLS_ECDH_RSA_WITH_AES_256_CBC_SHA = (ushort)49167,
++        TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 = (ushort)49194,
++        TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 = (ushort)49202,
++        TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 = (ushort)49230,
++        TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 = (ushort)49250,
++        TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 = (ushort)49231,
++        TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 = (ushort)49251,
++        TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)49272,
++        TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49292,
++        TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 = (ushort)49273,
++        TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49293,
++        TLS_ECDH_RSA_WITH_NULL_SHA = (ushort)49163,
++        TLS_ECDH_RSA_WITH_RC4_128_SHA = (ushort)49164,
++        TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 = (ushort)41,
++        TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA = (ushort)38,
++        TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5 = (ushort)42,
++        TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA = (ushort)39,
++        TLS_KRB5_EXPORT_WITH_RC4_40_MD5 = (ushort)43,
++        TLS_KRB5_EXPORT_WITH_RC4_40_SHA = (ushort)40,
++        TLS_KRB5_WITH_3DES_EDE_CBC_MD5 = (ushort)35,
++        TLS_KRB5_WITH_3DES_EDE_CBC_SHA = (ushort)31,
++        TLS_KRB5_WITH_DES_CBC_MD5 = (ushort)34,
++        TLS_KRB5_WITH_DES_CBC_SHA = (ushort)30,
++        TLS_KRB5_WITH_IDEA_CBC_MD5 = (ushort)37,
++        TLS_KRB5_WITH_IDEA_CBC_SHA = (ushort)33,
++        TLS_KRB5_WITH_RC4_128_MD5 = (ushort)36,
++        TLS_KRB5_WITH_RC4_128_SHA = (ushort)32,
++        TLS_NULL_WITH_NULL_NULL = (ushort)0,
++        TLS_PSK_DHE_WITH_AES_128_CCM_8 = (ushort)49322,
++        TLS_PSK_DHE_WITH_AES_256_CCM_8 = (ushort)49323,
++        TLS_PSK_WITH_3DES_EDE_CBC_SHA = (ushort)139,
++        TLS_PSK_WITH_AES_128_CBC_SHA = (ushort)140,
++        TLS_PSK_WITH_AES_128_CBC_SHA256 = (ushort)174,
++        TLS_PSK_WITH_AES_128_CCM = (ushort)49316,
++        TLS_PSK_WITH_AES_128_CCM_8 = (ushort)49320,
++        TLS_PSK_WITH_AES_128_GCM_SHA256 = (ushort)168,
++        TLS_PSK_WITH_AES_256_CBC_SHA = (ushort)141,
++        TLS_PSK_WITH_AES_256_CBC_SHA384 = (ushort)175,
++        TLS_PSK_WITH_AES_256_CCM = (ushort)49317,
++        TLS_PSK_WITH_AES_256_CCM_8 = (ushort)49321,
++        TLS_PSK_WITH_AES_256_GCM_SHA384 = (ushort)169,
++        TLS_PSK_WITH_ARIA_128_CBC_SHA256 = (ushort)49252,
++        TLS_PSK_WITH_ARIA_128_GCM_SHA256 = (ushort)49258,
++        TLS_PSK_WITH_ARIA_256_CBC_SHA384 = (ushort)49253,
++        TLS_PSK_WITH_ARIA_256_GCM_SHA384 = (ushort)49259,
++        TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)49300,
++        TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49294,
++        TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 = (ushort)49301,
++        TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49295,
++        TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 = (ushort)52395,
++        TLS_PSK_WITH_NULL_SHA = (ushort)44,
++        TLS_PSK_WITH_NULL_SHA256 = (ushort)176,
++        TLS_PSK_WITH_NULL_SHA384 = (ushort)177,
++        TLS_PSK_WITH_RC4_128_SHA = (ushort)138,
++        TLS_RSA_EXPORT_WITH_DES40_CBC_SHA = (ushort)8,
++        TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5 = (ushort)6,
++        TLS_RSA_EXPORT_WITH_RC4_40_MD5 = (ushort)3,
++        TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA = (ushort)147,
++        TLS_RSA_PSK_WITH_AES_128_CBC_SHA = (ushort)148,
++        TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 = (ushort)182,
++        TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 = (ushort)172,
++        TLS_RSA_PSK_WITH_AES_256_CBC_SHA = (ushort)149,
++        TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 = (ushort)183,
++        TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 = (ushort)173,
++        TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 = (ushort)49256,
++        TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 = (ushort)49262,
++        TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 = (ushort)49257,
++        TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 = (ushort)49263,
++        TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)49304,
++        TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49298,
++        TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 = (ushort)49305,
++        TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49299,
++        TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 = (ushort)52398,
++        TLS_RSA_PSK_WITH_NULL_SHA = (ushort)46,
++        TLS_RSA_PSK_WITH_NULL_SHA256 = (ushort)184,
++        TLS_RSA_PSK_WITH_NULL_SHA384 = (ushort)185,
++        TLS_RSA_PSK_WITH_RC4_128_SHA = (ushort)146,
++        TLS_RSA_WITH_3DES_EDE_CBC_SHA = (ushort)10,
++        TLS_RSA_WITH_AES_128_CBC_SHA = (ushort)47,
++        TLS_RSA_WITH_AES_128_CBC_SHA256 = (ushort)60,
++        TLS_RSA_WITH_AES_128_CCM = (ushort)49308,
++        TLS_RSA_WITH_AES_128_CCM_8 = (ushort)49312,
++        TLS_RSA_WITH_AES_128_GCM_SHA256 = (ushort)156,
++        TLS_RSA_WITH_AES_256_CBC_SHA = (ushort)53,
++        TLS_RSA_WITH_AES_256_CBC_SHA256 = (ushort)61,
++        TLS_RSA_WITH_AES_256_CCM = (ushort)49309,
++        TLS_RSA_WITH_AES_256_CCM_8 = (ushort)49313,
++        TLS_RSA_WITH_AES_256_GCM_SHA384 = (ushort)157,
++        TLS_RSA_WITH_ARIA_128_CBC_SHA256 = (ushort)49212,
++        TLS_RSA_WITH_ARIA_128_GCM_SHA256 = (ushort)49232,
++        TLS_RSA_WITH_ARIA_256_CBC_SHA384 = (ushort)49213,
++        TLS_RSA_WITH_ARIA_256_GCM_SHA384 = (ushort)49233,
++        TLS_RSA_WITH_CAMELLIA_128_CBC_SHA = (ushort)65,
++        TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 = (ushort)186,
++        TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 = (ushort)49274,
++        TLS_RSA_WITH_CAMELLIA_256_CBC_SHA = (ushort)132,
++        TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 = (ushort)192,
++        TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 = (ushort)49275,
++        TLS_RSA_WITH_DES_CBC_SHA = (ushort)9,
++        TLS_RSA_WITH_IDEA_CBC_SHA = (ushort)7,
++        TLS_RSA_WITH_NULL_MD5 = (ushort)1,
++        TLS_RSA_WITH_NULL_SHA = (ushort)2,
++        TLS_RSA_WITH_NULL_SHA256 = (ushort)59,
++        TLS_RSA_WITH_RC4_128_MD5 = (ushort)4,
++        TLS_RSA_WITH_RC4_128_SHA = (ushort)5,
++        TLS_RSA_WITH_SEED_CBC_SHA = (ushort)150,
++        TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA = (ushort)49180,
++        TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA = (ushort)49183,
++        TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA = (ushort)49186,
++        TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA = (ushort)49179,
++        TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA = (ushort)49182,
++        TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA = (ushort)49185,
++        TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA = (ushort)49178,
++        TLS_SRP_SHA_WITH_AES_128_CBC_SHA = (ushort)49181,
++        TLS_SRP_SHA_WITH_AES_256_CBC_SHA = (ushort)49184,
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Net.Sockets.md

@@ -0,0 +1,44 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public enum AddressFamily {
++        ControllerAreaNetwork = 65537,
++        Packet = 65536,
+     }
+     public class NetworkStream : Stream {
++        public override int Read(Span<byte> buffer);
++        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override int ReadByte();
++        public override void Write(ReadOnlySpan<byte> buffer);
++        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
++        public override void WriteByte(byte value);
+     }
+     public enum ProtocolFamily {
++        ControllerAreaNetwork = 65537,
++        Packet = 65536,
+     }
++    public sealed class SafeSocketHandle : SafeHandleMinusOneIsInvalid {
++        public SafeSocketHandle(IntPtr preexistingHandle, bool ownsHandle);
++        protected override bool ReleaseHandle();
++    }
+     public class SendPacketsElement {
++        public SendPacketsElement(FileStream fileStream);
++        public SendPacketsElement(FileStream fileStream, long offset, int count);
++        public SendPacketsElement(FileStream fileStream, long offset, int count, bool endOfPacket);
++        public SendPacketsElement(string filepath, long offset, int count);
++        public SendPacketsElement(string filepath, long offset, int count, bool endOfPacket);
++        public FileStream FileStream { get; }
++        public long OffsetLong { get; }
+     }
+     public class Socket : IDisposable {
++        public SafeSocketHandle SafeHandle { get; }
+     }
+     public enum SocketOptionName {
++        TcpKeepAliveInterval = 17,
++        TcpKeepAliveRetryCount = 16,
++        TcpKeepAliveTime = 3,
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Net.WebSockets.md

@@ -0,0 +1,11 @@
+# System.Net.WebSockets
+
+``` diff
+ namespace System.Net.WebSockets {
+     public sealed class ClientWebSocket : WebSocket {
++        public override ValueTask<ValueWebSocketReceiveResult> ReceiveAsync(Memory<byte> buffer, CancellationToken cancellationToken);
++        public override ValueTask SendAsync(ReadOnlyMemory<byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Net.md

@@ -0,0 +1,31 @@
+# System.Net
+
+``` diff
+ namespace System.Net {
+-    public class CookieCollection : ICollection, IEnumerable {
++    public class CookieCollection : ICollection, ICollection<Cookie>, IEnumerable, IEnumerable<Cookie>, IReadOnlyCollection<Cookie> {
++        public void Clear();
++        public bool Contains(Cookie cookie);
++        public bool Remove(Cookie cookie);
++        IEnumerator<Cookie> System.Collections.Generic.IEnumerable<System.Net.Cookie>.GetEnumerator();
+     }
+     public enum DecompressionMethods {
++        All = -1,
++        Brotli = 4,
+     }
+     public class FileWebRequest : WebRequest, ISerializable {
++        public override Task<Stream> GetRequestStreamAsync();
++        public override Task<WebResponse> GetResponseAsync();
+     }
+     public class IPEndPoint : EndPoint {
++        public static IPEndPoint Parse(ReadOnlySpan<char> s);
++        public static IPEndPoint Parse(string s);
++        public static bool TryParse(ReadOnlySpan<char> s, out IPEndPoint result);
++        public static bool TryParse(string s, out IPEndPoint result);
+     }
+     public enum SecurityProtocolType {
++        Tls13 = 12288,
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Numerics.md

@@ -0,0 +1,54 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
++    public static class BitOperations {
++        public static int LeadingZeroCount(uint value);
++        public static int LeadingZeroCount(ulong value);
++        public static int Log2(uint value);
++        public static int Log2(ulong value);
++        public static int PopCount(uint value);
++        public static int PopCount(ulong value);
++        public static uint RotateLeft(uint value, int offset);
++        public static ulong RotateLeft(ulong value, int offset);
++        public static uint RotateRight(uint value, int offset);
++        public static ulong RotateRight(ulong value, int offset);
++        public static int TrailingZeroCount(int value);
++        public static int TrailingZeroCount(long value);
++        public static int TrailingZeroCount(uint value);
++        public static int TrailingZeroCount(ulong value);
++    }
+     public struct Complex : IEquatable<Complex>, IFormattable {
++        public static readonly Complex Infinity;
++        public static readonly Complex NaN;
++        public static Complex Add(double left, Complex right);
++        public static Complex Add(Complex left, double right);
++        public static Complex Divide(double dividend, Complex divisor);
++        public static Complex Divide(Complex dividend, double divisor);
++        public static bool IsFinite(Complex value);
++        public static bool IsInfinity(Complex value);
++        public static bool IsNaN(Complex value);
++        public static Complex Multiply(double left, Complex right);
++        public static Complex Multiply(Complex left, double right);
++        public static Complex operator +(double left, Complex right);
++        public static Complex operator +(Complex left, double right);
++        public static Complex operator /(double left, Complex right);
++        public static Complex operator /(Complex left, double right);
++        public static Complex operator *(double left, Complex right);
++        public static Complex operator *(Complex left, double right);
++        public static Complex operator -(double left, Complex right);
++        public static Complex operator -(Complex left, double right);
++        public static Complex Subtract(double left, Complex right);
++        public static Complex Subtract(Complex left, double right);
+     }
+     public struct Vector<T> : IEquatable<Vector<T>>, IFormattable where T : struct {
++        public Vector(ReadOnlySpan<byte> values);
++        public Vector(ReadOnlySpan<T> values);
++        public void CopyTo(Span<byte> destination);
++        public void CopyTo(Span<T> destination);
++        public bool TryCopyTo(Span<byte> destination);
++        public bool TryCopyTo(Span<T> destination);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Reflection.Emit.md

@@ -0,0 +1,101 @@
+# System.Reflection.Emit
+
+``` diff
+ namespace System.Reflection.Emit {
+     public sealed class AssemblyBuilder : Assembly {
++        public override string CodeBase { get; }
++        public override MethodInfo EntryPoint { get; }
++        public override bool GlobalAssemblyCache { get; }
++        public override long HostContext { get; }
++        public override string ImageRuntimeVersion { get; }
++        public override string Location { get; }
++        public override bool ReflectionOnly { get; }
++        public override object[] GetCustomAttributes(bool inherit);
++        public override object[] GetCustomAttributes(Type attributeType, bool inherit);
++        public override IList<CustomAttributeData> GetCustomAttributesData();
++        public override Type[] GetExportedTypes();
++        public override FileStream GetFile(string name);
++        public override FileStream[] GetFiles(bool getResourceModules);
++        public override Module[] GetLoadedModules(bool getResourceModules);
++        public override Stream GetManifestResourceStream(Type type, string name);
++        public override Module GetModule(string name);
++        public override Module[] GetModules(bool getResourceModules);
++        public override AssemblyName GetName(bool copiedName);
++        public override AssemblyName[] GetReferencedAssemblies();
++        public override Assembly GetSatelliteAssembly(CultureInfo culture);
++        public override Assembly GetSatelliteAssembly(CultureInfo culture, Version version);
++        public override Type GetType(string name, bool throwOnError, bool ignoreCase);
++        public override bool IsDefined(Type attributeType, bool inherit);
+     }
++    public sealed class DynamicILInfo {
++        public DynamicMethod DynamicMethod { get; }
++        public int GetTokenFor(byte[] signature);
++        public int GetTokenFor(DynamicMethod method);
++        public int GetTokenFor(RuntimeFieldHandle field);
++        public int GetTokenFor(RuntimeFieldHandle field, RuntimeTypeHandle contextType);
++        public int GetTokenFor(RuntimeMethodHandle method);
++        public int GetTokenFor(RuntimeMethodHandle method, RuntimeTypeHandle contextType);
++        public int GetTokenFor(RuntimeTypeHandle type);
++        public int GetTokenFor(string literal);
++        public unsafe void SetCode(byte* code, int codeSize, int maxStackSize);
++        public void SetCode(byte[] code, int maxStackSize);
++        public unsafe void SetExceptions(byte* exceptions, int exceptionsSize);
++        public void SetExceptions(byte[] exceptions);
++        public unsafe void SetLocalSignature(byte* localSignature, int signatureSize);
++        public void SetLocalSignature(byte[] localSignature);
++    }
+     public sealed class DynamicMethod : MethodInfo {
++        public override bool IsSecurityCritical { get; }
++        public override bool IsSecuritySafeCritical { get; }
++        public override bool IsSecurityTransparent { get; }
++        public override Module Module { get; }
++        public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, string parameterName);
++        public DynamicILInfo GetDynamicILInfo();
+     }
+     public sealed class FieldBuilder : FieldInfo {
++        public override Module Module { get; }
+     }
+-    public struct Label
++    public readonly struct Label : IEquatable<Label>
+     public sealed class MethodBuilder : MethodInfo {
++        public override bool IsSecurityCritical { get; }
++        public override bool IsSecuritySafeCritical { get; }
++        public override bool IsSecurityTransparent { get; }
+     }
+     public class ModuleBuilder : Module {
++        public override int MDStreamVersion { get; }
++        public override int MetadataToken { get; }
++        public override Guid ModuleVersionId { get; }
++        public override string ScopeName { get; }
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public override object[] GetCustomAttributes(bool inherit);
++        public override object[] GetCustomAttributes(Type attributeType, bool inherit);
++        public override IList<CustomAttributeData> GetCustomAttributesData();
++        public override FieldInfo GetField(string name, BindingFlags bindingAttr);
++        public override FieldInfo[] GetFields(BindingFlags bindingFlags);
++        public override MethodInfo[] GetMethods(BindingFlags bindingFlags);
++        public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine);
++        public override Type GetType(string className);
++        public override Type GetType(string className, bool ignoreCase);
++        public override Type GetType(string className, bool throwOnError, bool ignoreCase);
++        public override Type[] GetTypes();
++        public override bool IsDefined(Type attributeType, bool inherit);
++        public override bool IsResource();
++        public override FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);
++        public override MemberInfo ResolveMember(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);
++        public override MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);
++        public override byte[] ResolveSignature(int metadataToken);
++        public override string ResolveString(int metadataToken);
++        public override Type ResolveType(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments);
+     }
+-    public struct OpCode
++    public readonly struct OpCode : IEquatable<OpCode>
+     public sealed class TypeBuilder : Type {
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet);
++        public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Reflection.Metadata.md

@@ -0,0 +1,10 @@
+# System.Reflection.Metadata
+
+``` diff
+ namespace System.Reflection.Metadata {
+     public class ImageFormatLimitationException : Exception {
++        protected ImageFormatLimitationException(SerializationInfo info, StreamingContext context);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Reflection.md

@@ -0,0 +1,37 @@
+# System.Reflection
+
+``` diff
+ namespace System.Reflection {
+     public abstract class Assembly : ICustomAttributeProvider, ISerializable {
++        public virtual bool IsCollectible { get; }
+     }
+     public class CustomAttributeData {
+-        public Type AttributeType { get; }
++        public virtual Type AttributeType { get; }
+     }
+-    public struct CustomAttributeNamedArgument
++    public readonly struct CustomAttributeNamedArgument
+-    public struct CustomAttributeTypedArgument
++    public readonly struct CustomAttributeTypedArgument
++    public interface ICustomTypeProvider {
++        Type GetCustomType();
++    }
+     public abstract class MemberInfo : ICustomAttributeProvider {
++        public virtual bool IsCollectible { get; }
+     }
+     public enum MethodImplAttributes {
++        AggressiveOptimization = 512,
+     }
+     public sealed class ReflectionTypeLoadException : SystemException, ISerializable {
++        public override string Message { get; }
++        public override string ToString();
+     }
+     public class TypeDelegator : TypeInfo {
++        public override bool IsCollectible { get; }
+     }
+     public abstract class TypeInfo : Type, IReflectableType {
++        protected TypeInfo();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Runtime.CompilerServices.md

@@ -0,0 +1,103 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
++    public struct AsyncIteratorMethodBuilder {
++        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine;
++        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine;
++        public void Complete();
++        public static AsyncIteratorMethodBuilder Create();
++        public void MoveNext<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine;
++    }
++    public sealed class AsyncIteratorStateMachineAttribute : StateMachineAttribute {
++        public AsyncIteratorStateMachineAttribute(Type stateMachineType);
++    }
++    public sealed class CallerArgumentExpressionAttribute : Attribute {
++        public CallerArgumentExpressionAttribute(string parameterName);
++        public string ParameterName { get; }
++    }
+     public sealed class ConditionalWeakTable<TKey, TValue> : IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>> where TKey : class where TValue : class {
+-        ~ConditionalWeakTable();
+
+     }
++    public readonly struct ConfiguredAsyncDisposable {
++        public ConfiguredValueTaskAwaitable DisposeAsync();
++    }
++    public readonly struct ConfiguredCancelableAsyncEnumerable<T> {
++        public ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait(bool continueOnCapturedContext);
++        public ConfiguredCancelableAsyncEnumerable<T>.Enumerator GetAsyncEnumerator();
++        public ConfiguredCancelableAsyncEnumerable<T> WithCancellation(CancellationToken cancellationToken);
++        public readonly struct Enumerator {
++            public T Current { get; }
++            public ConfiguredValueTaskAwaitable DisposeAsync();
++            public ConfiguredValueTaskAwaitable<bool> MoveNextAsync();
++        }
++    }
++    public sealed class EnumeratorCancellationAttribute : Attribute {
++        public EnumeratorCancellationAttribute();
++    }
++    public sealed class IDispatchConstantAttribute : CustomConstantAttribute {
++        public IDispatchConstantAttribute();
++        public override object Value { get; }
++    }
+     public enum MethodImplOptions {
++        AggressiveOptimization = 512,
+     }
+     public static class RuntimeFeature {
++        public const string DefaultImplementationsOfInterfaces = "DefaultImplementationsOfInterfaces";
++        public static bool IsDynamicCodeCompiled { get; }
++        public static bool IsDynamicCodeSupported { get; }
+     }
+     public static class RuntimeHelpers {
++        public static T[] GetSubArray<T>(T[] array, Range range);
+     }
++    public sealed class SwitchExpressionException : InvalidOperationException {
++        public SwitchExpressionException();
++        public SwitchExpressionException(Exception innerException);
++        public SwitchExpressionException(object unmatchedValue);
++        public SwitchExpressionException(string message);
++        public SwitchExpressionException(string message, Exception innerException);
++        public override string Message { get; }
++        public object UnmatchedValue { get; }
++        public override void GetObjectData(SerializationInfo info, StreamingContext context);
++    }
++    public static class Unsafe {
++        public unsafe static void* Add<T>(void* source, int elementOffset);
++        public static ref T Add<T>(ref T source, int elementOffset);
++        public static ref T Add<T>(ref T source, IntPtr elementOffset);
++        public static ref T AddByteOffset<T>(ref T source, IntPtr byteOffset);
++        public static bool AreSame<T>(ref T left, ref T right);
++        public static T As<T>(object o) where T : class;
++        public static ref TTo As<TFrom, TTo>(ref TFrom source);
++        public unsafe static void* AsPointer<T>(ref T value);
++        public unsafe static ref T AsRef<T>(void* source);
++        public static ref T AsRef<T>(in T source);
++        public static IntPtr ByteOffset<T>(ref T origin, ref T target);
++        public unsafe static void Copy<T>(void* destination, ref T source);
++        public unsafe static void Copy<T>(ref T destination, void* source);
++        public static void CopyBlock(ref byte destination, ref byte source, uint byteCount);
++        public unsafe static void CopyBlock(void* destination, void* source, uint byteCount);
++        public static void CopyBlockUnaligned(ref byte destination, ref byte source, uint byteCount);
++        public unsafe static void CopyBlockUnaligned(void* destination, void* source, uint byteCount);
++        public static void InitBlock(ref byte startAddress, byte value, uint byteCount);
++        public unsafe static void InitBlock(void* startAddress, byte value, uint byteCount);
++        public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount);
++        public unsafe static void InitBlockUnaligned(void* startAddress, byte value, uint byteCount);
++        public static bool IsAddressGreaterThan<T>(ref T left, ref T right);
++        public static bool IsAddressLessThan<T>(ref T left, ref T right);
++        public unsafe static T Read<T>(void* source);
++        public static T ReadUnaligned<T>(ref byte source);
++        public unsafe static T ReadUnaligned<T>(void* source);
++        public static int SizeOf<T>();
++        public unsafe static void* Subtract<T>(void* source, int elementOffset);
++        public static ref T Subtract<T>(ref T source, int elementOffset);
++        public static ref T Subtract<T>(ref T source, IntPtr elementOffset);
++        public static ref T SubtractByteOffset<T>(ref T source, IntPtr byteOffset);
++        public static ref T Unbox<T>(object box) where T : struct;
++        public unsafe static void Write<T>(void* destination, T value);
++        public static void WriteUnaligned<T>(ref byte destination, T value);
++        public unsafe static void WriteUnaligned<T>(void* destination, T value);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Runtime.InteropServices.md

@@ -0,0 +1,44 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+     public class ComAwareEventInfo : EventInfo {
++        public override int MetadataToken { get; }
++        public override Module Module { get; }
++        public override IList<CustomAttributeData> GetCustomAttributesData();
++        public override MethodInfo[] GetOtherMethods(bool nonPublic);
+     }
++    public delegate IntPtr DllImportResolver(string libraryName, Assembly assembly, DllImportSearchPath? searchPath);
+-    public struct HandleRef
++    public readonly struct HandleRef
+     public static class Marshal {
++        public static int GetEndComSlot(Type t);
++        public static IntPtr GetExceptionPointers();
++        public static bool IsTypeVisibleFromCom(Type t);
+     }
+     public static class MemoryMarshal {
++        public static ref readonly T AsRef<T>(ReadOnlySpan<byte> span) where T : struct;
++        public static ref T AsRef<T>(Span<byte> span) where T : struct;
+     }
++    public static class NativeLibrary {
++        public static void Free(IntPtr handle);
++        public static IntPtr GetExport(IntPtr handle, string name);
++        public static IntPtr Load(string libraryPath);
++        public static IntPtr Load(string libraryName, Assembly assembly, DllImportSearchPath? searchPath);
++        public static void SetDllImportResolver(Assembly assembly, DllImportResolver resolver);
++        public static bool TryGetExport(IntPtr handle, string name, out IntPtr address);
++        public static bool TryLoad(string libraryPath, out IntPtr handle);
++        public static bool TryLoad(string libraryName, Assembly assembly, DllImportSearchPath? searchPath, out IntPtr handle);
++    }
+     public readonly struct OSPlatform : IEquatable<OSPlatform> {
++        public static OSPlatform FreeBSD { get; }
+     }
+     public static class SequenceMarshal {
++        public static bool TryRead<T>(ref SequenceReader<byte> reader, out T value) where T : struct;
+     }
++    public class StandardOleMarshalObject : MarshalByRefObject {
++        protected StandardOleMarshalObject();
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Runtime.Intrinsics.md

@@ -0,0 +1,222 @@
+# System.Runtime.Intrinsics
+
+``` diff
++namespace System.Runtime.Intrinsics {
++    public static class Vector128 {
++        public static Vector128<U> As<T, U>(this Vector128<T> vector) where T : struct where U : struct;
++        public static Vector128<Byte> AsByte<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<Double> AsDouble<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<Int16> AsInt16<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<Int32> AsInt32<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<Int64> AsInt64<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<SByte> AsSByte<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<Single> AsSingle<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<UInt16> AsUInt16<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<UInt32> AsUInt32<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<UInt64> AsUInt64<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<Byte> Create(byte value);
++        public static Vector128<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15);
++        public static Vector128<Double> Create(double value);
++        public static Vector128<Double> Create(double e0, double e1);
++        public static Vector128<Int16> Create(short value);
++        public static Vector128<Int16> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7);
++        public static Vector128<Int32> Create(int value);
++        public static Vector128<Int32> Create(int e0, int e1, int e2, int e3);
++        public static Vector128<Int64> Create(long value);
++        public static Vector128<Int64> Create(long e0, long e1);
++        public static Vector128<Byte> Create(Vector64<byte> lower, Vector64<byte> upper);
++        public static Vector128<Double> Create(Vector64<double> lower, Vector64<double> upper);
++        public static Vector128<Int16> Create(Vector64<short> lower, Vector64<short> upper);
++        public static Vector128<Int32> Create(Vector64<int> lower, Vector64<int> upper);
++        public static Vector128<Int64> Create(Vector64<long> lower, Vector64<long> upper);
++        public static Vector128<SByte> Create(Vector64<sbyte> lower, Vector64<sbyte> upper);
++        public static Vector128<Single> Create(Vector64<float> lower, Vector64<float> upper);
++        public static Vector128<UInt16> Create(Vector64<ushort> lower, Vector64<ushort> upper);
++        public static Vector128<UInt32> Create(Vector64<uint> lower, Vector64<uint> upper);
++        public static Vector128<UInt64> Create(Vector64<ulong> lower, Vector64<ulong> upper);
++        public static Vector128<SByte> Create(sbyte value);
++        public static Vector128<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15);
++        public static Vector128<Single> Create(float value);
++        public static Vector128<Single> Create(float e0, float e1, float e2, float e3);
++        public static Vector128<UInt16> Create(ushort value);
++        public static Vector128<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7);
++        public static Vector128<UInt32> Create(uint value);
++        public static Vector128<UInt32> Create(uint e0, uint e1, uint e2, uint e3);
++        public static Vector128<UInt64> Create(ulong value);
++        public static Vector128<UInt64> Create(ulong e0, ulong e1);
++        public static Vector128<Byte> CreateScalar(byte value);
++        public static Vector128<Double> CreateScalar(double value);
++        public static Vector128<Int16> CreateScalar(short value);
++        public static Vector128<Int32> CreateScalar(int value);
++        public static Vector128<Int64> CreateScalar(long value);
++        public static Vector128<SByte> CreateScalar(sbyte value);
++        public static Vector128<Single> CreateScalar(float value);
++        public static Vector128<UInt16> CreateScalar(ushort value);
++        public static Vector128<UInt32> CreateScalar(uint value);
++        public static Vector128<UInt64> CreateScalar(ulong value);
++        public static Vector128<Byte> CreateScalarUnsafe(byte value);
++        public static Vector128<Double> CreateScalarUnsafe(double value);
++        public static Vector128<Int16> CreateScalarUnsafe(short value);
++        public static Vector128<Int32> CreateScalarUnsafe(int value);
++        public static Vector128<Int64> CreateScalarUnsafe(long value);
++        public static Vector128<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector128<Single> CreateScalarUnsafe(float value);
++        public static Vector128<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector128<UInt32> CreateScalarUnsafe(uint value);
++        public static Vector128<UInt64> CreateScalarUnsafe(ulong value);
++        public static T GetElement<T>(this Vector128<T> vector, int index) where T : struct;
++        public static Vector64<T> GetLower<T>(this Vector128<T> vector) where T : struct;
++        public static Vector64<T> GetUpper<T>(this Vector128<T> vector) where T : struct;
++        public static T ToScalar<T>(this Vector128<T> vector) where T : struct;
++        public static Vector256<T> ToVector256<T>(this Vector128<T> vector) where T : struct;
++        public static Vector256<T> ToVector256Unsafe<T>(this Vector128<T> vector) where T : struct;
++        public static Vector128<T> WithElement<T>(this Vector128<T> vector, int index, T value) where T : struct;
++        public static Vector128<T> WithLower<T>(this Vector128<T> vector, Vector64<T> value) where T : struct;
++        public static Vector128<T> WithUpper<T>(this Vector128<T> vector, Vector64<T> value) where T : struct;
++    }
++    public readonly struct Vector128<T> : IEquatable<Vector128<T>> where T : struct {
++        public static int Count { get; }
++        public static Vector128<T> Zero { get; }
++        public override bool Equals(object obj);
++        public bool Equals(Vector128<T> other);
++        public override int GetHashCode();
++        public override string ToString();
++    }
++    public static class Vector256 {
++        public static Vector256<U> As<T, U>(this Vector256<T> vector) where T : struct where U : struct;
++        public static Vector256<Byte> AsByte<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<Double> AsDouble<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<Int16> AsInt16<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<Int32> AsInt32<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<Int64> AsInt64<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<SByte> AsSByte<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<Single> AsSingle<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<UInt16> AsUInt16<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<UInt32> AsUInt32<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<UInt64> AsUInt64<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<Byte> Create(byte value);
++        public static Vector256<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31);
++        public static Vector256<Double> Create(double value);
++        public static Vector256<Double> Create(double e0, double e1, double e2, double e3);
++        public static Vector256<Int16> Create(short value);
++        public static Vector256<Int16> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15);
++        public static Vector256<Int32> Create(int value);
++        public static Vector256<Int32> Create(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7);
++        public static Vector256<Int64> Create(long value);
++        public static Vector256<Int64> Create(long e0, long e1, long e2, long e3);
++        public static Vector256<Byte> Create(Vector128<byte> lower, Vector128<byte> upper);
++        public static Vector256<Double> Create(Vector128<double> lower, Vector128<double> upper);
++        public static Vector256<Int16> Create(Vector128<short> lower, Vector128<short> upper);
++        public static Vector256<Int32> Create(Vector128<int> lower, Vector128<int> upper);
++        public static Vector256<Int64> Create(Vector128<long> lower, Vector128<long> upper);
++        public static Vector256<SByte> Create(Vector128<sbyte> lower, Vector128<sbyte> upper);
++        public static Vector256<Single> Create(Vector128<float> lower, Vector128<float> upper);
++        public static Vector256<UInt16> Create(Vector128<ushort> lower, Vector128<ushort> upper);
++        public static Vector256<UInt32> Create(Vector128<uint> lower, Vector128<uint> upper);
++        public static Vector256<UInt64> Create(Vector128<ulong> lower, Vector128<ulong> upper);
++        public static Vector256<SByte> Create(sbyte value);
++        public static Vector256<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31);
++        public static Vector256<Single> Create(float value);
++        public static Vector256<Single> Create(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7);
++        public static Vector256<UInt16> Create(ushort value);
++        public static Vector256<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15);
++        public static Vector256<UInt32> Create(uint value);
++        public static Vector256<UInt32> Create(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7);
++        public static Vector256<UInt64> Create(ulong value);
++        public static Vector256<UInt64> Create(ulong e0, ulong e1, ulong e2, ulong e3);
++        public static Vector256<Byte> CreateScalar(byte value);
++        public static Vector256<Double> CreateScalar(double value);
++        public static Vector256<Int16> CreateScalar(short value);
++        public static Vector256<Int32> CreateScalar(int value);
++        public static Vector256<Int64> CreateScalar(long value);
++        public static Vector256<SByte> CreateScalar(sbyte value);
++        public static Vector256<Single> CreateScalar(float value);
++        public static Vector256<UInt16> CreateScalar(ushort value);
++        public static Vector256<UInt32> CreateScalar(uint value);
++        public static Vector256<UInt64> CreateScalar(ulong value);
++        public static Vector256<Byte> CreateScalarUnsafe(byte value);
++        public static Vector256<Double> CreateScalarUnsafe(double value);
++        public static Vector256<Int16> CreateScalarUnsafe(short value);
++        public static Vector256<Int32> CreateScalarUnsafe(int value);
++        public static Vector256<Int64> CreateScalarUnsafe(long value);
++        public static Vector256<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector256<Single> CreateScalarUnsafe(float value);
++        public static Vector256<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector256<UInt32> CreateScalarUnsafe(uint value);
++        public static Vector256<UInt64> CreateScalarUnsafe(ulong value);
++        public static T GetElement<T>(this Vector256<T> vector, int index) where T : struct;
++        public static Vector128<T> GetLower<T>(this Vector256<T> vector) where T : struct;
++        public static Vector128<T> GetUpper<T>(this Vector256<T> vector) where T : struct;
++        public static T ToScalar<T>(this Vector256<T> vector) where T : struct;
++        public static Vector256<T> WithElement<T>(this Vector256<T> vector, int index, T value) where T : struct;
++        public static Vector256<T> WithLower<T>(this Vector256<T> vector, Vector128<T> value) where T : struct;
++        public static Vector256<T> WithUpper<T>(this Vector256<T> vector, Vector128<T> value) where T : struct;
++    }
++    public readonly struct Vector256<T> : IEquatable<Vector256<T>> where T : struct {
++        public static int Count { get; }
++        public static Vector256<T> Zero { get; }
++        public override bool Equals(object obj);
++        public bool Equals(Vector256<T> other);
++        public override int GetHashCode();
++        public override string ToString();
++    }
++    public static class Vector64 {
++        public static Vector64<U> As<T, U>(this Vector64<T> vector) where T : struct where U : struct;
++        public static Vector64<Byte> AsByte<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<Double> AsDouble<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<Int16> AsInt16<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<Int32> AsInt32<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<Int64> AsInt64<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<SByte> AsSByte<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<Single> AsSingle<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<UInt16> AsUInt16<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<UInt32> AsUInt32<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<UInt64> AsUInt64<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<Byte> Create(byte value);
++        public static Vector64<Byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7);
++        public static Vector64<Double> Create(double value);
++        public static Vector64<Int16> Create(short value);
++        public static Vector64<Int16> Create(short e0, short e1, short e2, short e3);
++        public static Vector64<Int32> Create(int value);
++        public static Vector64<Int32> Create(int e0, int e1);
++        public static Vector64<Int64> Create(long value);
++        public static Vector64<SByte> Create(sbyte value);
++        public static Vector64<SByte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7);
++        public static Vector64<Single> Create(float value);
++        public static Vector64<Single> Create(float e0, float e1);
++        public static Vector64<UInt16> Create(ushort value);
++        public static Vector64<UInt16> Create(ushort e0, ushort e1, ushort e2, ushort e3);
++        public static Vector64<UInt32> Create(uint value);
++        public static Vector64<UInt32> Create(uint e0, uint e1);
++        public static Vector64<UInt64> Create(ulong value);
++        public static Vector64<Byte> CreateScalar(byte value);
++        public static Vector64<Int16> CreateScalar(short value);
++        public static Vector64<Int32> CreateScalar(int value);
++        public static Vector64<SByte> CreateScalar(sbyte value);
++        public static Vector64<Single> CreateScalar(float value);
++        public static Vector64<UInt16> CreateScalar(ushort value);
++        public static Vector64<UInt32> CreateScalar(uint value);
++        public static Vector64<Byte> CreateScalarUnsafe(byte value);
++        public static Vector64<Int16> CreateScalarUnsafe(short value);
++        public static Vector64<Int32> CreateScalarUnsafe(int value);
++        public static Vector64<SByte> CreateScalarUnsafe(sbyte value);
++        public static Vector64<Single> CreateScalarUnsafe(float value);
++        public static Vector64<UInt16> CreateScalarUnsafe(ushort value);
++        public static Vector64<UInt32> CreateScalarUnsafe(uint value);
++        public static T GetElement<T>(this Vector64<T> vector, int index) where T : struct;
++        public static T ToScalar<T>(this Vector64<T> vector) where T : struct;
++        public static Vector128<T> ToVector128<T>(this Vector64<T> vector) where T : struct;
++        public static Vector128<T> ToVector128Unsafe<T>(this Vector64<T> vector) where T : struct;
++        public static Vector64<T> WithElement<T>(this Vector64<T> vector, int index, T value) where T : struct;
++    }
++    public readonly struct Vector64<T> : IEquatable<Vector64<T>> where T : struct {
++        public static int Count { get; }
++        public static Vector64<T> Zero { get; }
++        public override bool Equals(object obj);
++        public bool Equals(Vector64<T> other);
++        public override int GetHashCode();
++        public override string ToString();
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Runtime.Loader.md

@@ -0,0 +1,33 @@
+# System.Runtime.Loader
+
+``` diff
+ namespace System.Runtime.Loader {
++    public sealed class AssemblyDependencyResolver {
++        public AssemblyDependencyResolver(string componentAssemblyPath);
++        public string ResolveAssemblyToPath(AssemblyName assemblyName);
++        public string ResolveUnmanagedDllToPath(string unmanagedDllName);
++    }
+-    public abstract class AssemblyLoadContext {
++    public class AssemblyLoadContext {
++        protected AssemblyLoadContext(bool isCollectible);
++        public AssemblyLoadContext(string name, bool isCollectible = false);
++        public static IEnumerable<AssemblyLoadContext> All { get; }
++        public IEnumerable<Assembly> Assemblies { get; }
++        public static AssemblyLoadContext CurrentContextualReflectionContext { get; }
++        public bool IsCollectible { get; }
++        public string Name { get; }
++        public event Func<Assembly, string, IntPtr> ResolvingUnmanagedDll;
++        public AssemblyLoadContext.ContextualReflectionScope EnterContextualReflection();
++        public static AssemblyLoadContext.ContextualReflectionScope EnterContextualReflection(Assembly activating);
++        ~AssemblyLoadContext();
+-        protected abstract Assembly Load(AssemblyName assemblyName);
++        protected virtual Assembly Load(AssemblyName assemblyName);
++        public override string ToString();
++        public void Unload();
++        public struct ContextualReflectionScope : IDisposable {
++            public void Dispose();
++        }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Runtime.Remoting.md

@@ -0,0 +1,11 @@
+# System.Runtime.Remoting
+
+``` diff
++namespace System.Runtime.Remoting {
++    public class ObjectHandle : MarshalByRefObject {
++        public ObjectHandle(object o);
++        public object Unwrap();
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Runtime.Serialization.md

@@ -0,0 +1,9 @@
+# System.Runtime.Serialization
+
+``` diff
+ namespace System.Runtime.Serialization {
+-    public struct SerializationEntry
++    public readonly struct SerializationEntry
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Runtime.md

@@ -0,0 +1,16 @@
+# System.Runtime
+
+``` diff
+ namespace System.Runtime {
++    public sealed class AmbiguousImplementationException : Exception {
++        public AmbiguousImplementationException();
++        public AmbiguousImplementationException(string message);
++        public AmbiguousImplementationException(string message, Exception innerException);
++    }
++    public static class ProfileOptimization {
++        public static void SetProfileRoot(string directoryPath);
++        public static void StartProfile(string profile);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Security.Authentication.md

@@ -0,0 +1,10 @@
+# System.Security.Authentication
+
+``` diff
+ namespace System.Security.Authentication {
+     public enum SslProtocols {
++        Tls13 = 12288,
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Security.Cryptography.md

@@ -0,0 +1,150 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
++    public sealed class AesCcm : IDisposable {
++        public AesCcm(byte[] key);
++        public AesCcm(ReadOnlySpan<byte> key);
++        public static KeySizes NonceByteSizes { get; }
++        public static KeySizes TagByteSizes { get; }
++        public void Decrypt(byte[] nonce, byte[] ciphertext, byte[] tag, byte[] plaintext, byte[] associatedData = null);
++        public void Decrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> ciphertext, ReadOnlySpan<byte> tag, Span<byte> plaintext, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++        public void Dispose();
++        public void Encrypt(byte[] nonce, byte[] plaintext, byte[] ciphertext, byte[] tag, byte[] associatedData = null);
++        public void Encrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> plaintext, Span<byte> ciphertext, Span<byte> tag, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++    }
++    public sealed class AesGcm : IDisposable {
++        public AesGcm(byte[] key);
++        public AesGcm(ReadOnlySpan<byte> key);
++        public static KeySizes NonceByteSizes { get; }
++        public static KeySizes TagByteSizes { get; }
++        public void Decrypt(byte[] nonce, byte[] ciphertext, byte[] tag, byte[] plaintext, byte[] associatedData = null);
++        public void Decrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> ciphertext, ReadOnlySpan<byte> tag, Span<byte> plaintext, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++        public void Dispose();
++        public void Encrypt(byte[] nonce, byte[] plaintext, byte[] ciphertext, byte[] tag, byte[] associatedData = null);
++        public void Encrypt(ReadOnlySpan<byte> nonce, ReadOnlySpan<byte> plaintext, Span<byte> ciphertext, Span<byte> tag, ReadOnlySpan<byte> associatedData = default(ReadOnlySpan<byte>));
++    }
+     public abstract class AsymmetricAlgorithm : IDisposable {
++        public virtual byte[] ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters);
++        public virtual byte[] ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters);
++        public virtual byte[] ExportPkcs8PrivateKey();
++        public virtual byte[] ExportSubjectPublicKeyInfo();
++        public virtual void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
+     }
+     public class CryptoStream : Stream, IDisposable {
++        public override ValueTask DisposeAsync();
+     }
+     public abstract class DSA : AsymmetricAlgorithm {
++        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
++        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public override bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
++        public override bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
+     }
+     public abstract class ECDiffieHellman : AsymmetricAlgorithm {
++        public virtual byte[] ExportECPrivateKey();
++        public virtual void ImportECPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportECPrivateKey(Span<byte> destination, out int bytesWritten);
++        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public override bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
++        public override bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
+     }
+     public abstract class ECDsa : AsymmetricAlgorithm {
++        public virtual byte[] ExportECPrivateKey();
++        public virtual void ImportECPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual bool TryExportECPrivateKey(Span<byte> destination, out int bytesWritten);
++        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public override bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
++        public override bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class MD5CryptoServiceProvider : MD5 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
++    public enum PbeEncryptionAlgorithm {
++        Aes128Cbc = 1,
++        Aes192Cbc = 2,
++        Aes256Cbc = 3,
++        TripleDes3KeyPkcs12 = 4,
++        Unknown = 0,
++    }
++    public sealed class PbeParameters {
++        public PbeParameters(PbeEncryptionAlgorithm encryptionAlgorithm, HashAlgorithmName hashAlgorithm, int iterationCount);
++        public PbeEncryptionAlgorithm EncryptionAlgorithm { get; }
++        public HashAlgorithmName HashAlgorithm { get; }
++        public int IterationCount { get; }
++    }
+     public abstract class RandomNumberGenerator : IDisposable {
++        public static int GetInt32(int toExclusive);
++        public static int GetInt32(int fromInclusive, int toExclusive);
+     }
+     public sealed class RNGCryptoServiceProvider : RandomNumberGenerator {
++        public override void GetBytes(byte[] data, int offset, int count);
++        public override void GetBytes(Span<byte> data);
++        public override void GetNonZeroBytes(Span<byte> data);
+     }
+     public abstract class RSA : AsymmetricAlgorithm {
++        public virtual byte[] ExportRSAPrivateKey();
++        public virtual byte[] ExportRSAPublicKey();
++        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportRSAPrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public virtual void ImportRSAPublicKey(ReadOnlySpan<byte> source, out int bytesRead);
++        public override void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
++        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        public override bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportRSAPrivateKey(Span<byte> destination, out int bytesWritten);
++        public virtual bool TryExportRSAPublicKey(Span<byte> destination, out int bytesWritten);
++        public override bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA1CryptoServiceProvider : SHA1 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA256CryptoServiceProvider : SHA256 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA384CryptoServiceProvider : SHA384 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+     public sealed class SHA512CryptoServiceProvider : SHA512 {
+-        protected sealed override void Dispose(bool disposing);
++        protected override void Dispose(bool disposing);
++        protected override void HashCore(ReadOnlySpan<byte> source);
++        protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Security.Permissions.md

@@ -0,0 +1,11 @@
+# System.Security.Permissions
+
+``` diff
+ namespace System.Security.Permissions {
++    public enum PermissionState {
++        None = 0,
++        Unrestricted = 1,
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Security.md

@@ -0,0 +1,51 @@
+# System.Security
+
+``` diff
+ namespace System.Security {
++    public interface IStackWalk {
++        void Assert();
++        void Demand();
++        void Deny();
++        void PermitOnly();
++    }
++    public class PermissionSet : ICollection, IDeserializationCallback, IEnumerable, ISecurityEncodable, IStackWalk {
++        public PermissionSet(PermissionState state);
++        public PermissionSet(PermissionSet permSet);
++        public virtual int Count { get; }
++        public virtual bool IsReadOnly { get; }
++        public virtual bool IsSynchronized { get; }
++        public virtual object SyncRoot { get; }
++        public IPermission AddPermission(IPermission perm);
++        protected virtual IPermission AddPermissionImpl(IPermission perm);
++        public void Assert();
++        public bool ContainsNonCodeAccessPermissions();
++        public static byte[] ConvertPermissionSet(string inFormat, byte[] inData, string outFormat);
++        public virtual PermissionSet Copy();
++        public virtual void CopyTo(Array array, int index);
++        public void Demand();
++        public void Deny();
++        public override bool Equals(object o);
++        public virtual void FromXml(SecurityElement et);
++        public IEnumerator GetEnumerator();
++        protected virtual IEnumerator GetEnumeratorImpl();
++        public override int GetHashCode();
++        public IPermission GetPermission(Type permClass);
++        protected virtual IPermission GetPermissionImpl(Type permClass);
++        public PermissionSet Intersect(PermissionSet other);
++        public bool IsEmpty();
++        public bool IsSubsetOf(PermissionSet target);
++        public bool IsUnrestricted();
++        public void PermitOnly();
++        public IPermission RemovePermission(Type permClass);
++        protected virtual IPermission RemovePermissionImpl(Type permClass);
++        public static void RevertAssert();
++        public IPermission SetPermission(IPermission perm);
++        protected virtual IPermission SetPermissionImpl(IPermission perm);
++        void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender);
++        public override string ToString();
++        public virtual SecurityElement ToXml();
++        public PermissionSet Union(PermissionSet other);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Text.Encodings.Web.md

@@ -0,0 +1,56 @@
+# System.Text.Encodings.Web
+
+``` diff
++namespace System.Text.Encodings.Web {
++    public abstract class HtmlEncoder : TextEncoder {
++        protected HtmlEncoder();
++        public static HtmlEncoder Default { get; }
++        public static HtmlEncoder Create(TextEncoderSettings settings);
++        public static HtmlEncoder Create(params UnicodeRange[] allowedRanges);
++    }
++    public abstract class JavaScriptEncoder : TextEncoder {
++        protected JavaScriptEncoder();
++        public static JavaScriptEncoder Default { get; }
++        public static JavaScriptEncoder UnsafeRelaxedJsonEscaping { get; }
++        public static JavaScriptEncoder Create(TextEncoderSettings settings);
++        public static JavaScriptEncoder Create(params UnicodeRange[] allowedRanges);
++    }
++    public abstract class TextEncoder {
++        protected TextEncoder();
++        public abstract int MaxOutputCharactersPerInputCharacter { get; }
++        public virtual void Encode(TextWriter output, char[] value, int startIndex, int characterCount);
++        public void Encode(TextWriter output, string value);
++        public virtual void Encode(TextWriter output, string value, int startIndex, int characterCount);
++        public virtual OperationStatus Encode(ReadOnlySpan<char> source, Span<char> destination, out int charsConsumed, out int charsWritten, bool isFinalBlock = true);
++        public virtual string Encode(string value);
++        public virtual OperationStatus EncodeUtf8(ReadOnlySpan<byte> utf8Source, Span<byte> utf8Destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true);
++        public unsafe abstract int FindFirstCharacterToEncode(char* text, int textLength);
++        public virtual int FindFirstCharacterToEncodeUtf8(ReadOnlySpan<byte> utf8Text);
++        public unsafe abstract bool TryEncodeUnicodeScalar(int unicodeScalar, char* buffer, int bufferLength, out int numberOfCharactersWritten);
++        public abstract bool WillEncode(int unicodeScalar);
++    }
++    public class TextEncoderSettings {
++        public TextEncoderSettings();
++        public TextEncoderSettings(TextEncoderSettings other);
++        public TextEncoderSettings(params UnicodeRange[] allowedRanges);
++        public virtual void AllowCharacter(char character);
++        public virtual void AllowCharacters(params char[] characters);
++        public virtual void AllowCodePoints(IEnumerable<int> codePoints);
++        public virtual void AllowRange(UnicodeRange range);
++        public virtual void AllowRanges(params UnicodeRange[] ranges);
++        public virtual void Clear();
++        public virtual void ForbidCharacter(char character);
++        public virtual void ForbidCharacters(params char[] characters);
++        public virtual void ForbidRange(UnicodeRange range);
++        public virtual void ForbidRanges(params UnicodeRange[] ranges);
++        public virtual IEnumerable<int> GetAllowedCodePoints();
++    }
++    public abstract class UrlEncoder : TextEncoder {
++        protected UrlEncoder();
++        public static UrlEncoder Default { get; }
++        public static UrlEncoder Create(TextEncoderSettings settings);
++        public static UrlEncoder Create(params UnicodeRange[] allowedRanges);
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Text.Json.Serialization.md

@@ -0,0 +1,45 @@
+# System.Text.Json.Serialization
+
+``` diff
++namespace System.Text.Json.Serialization {
++    public abstract class JsonAttribute : Attribute {
++        protected JsonAttribute();
++    }
++    public abstract class JsonConverter {
++        public abstract bool CanConvert(Type typeToConvert);
++    }
++    public abstract class JsonConverter<T> : JsonConverter {
++        protected internal JsonConverter();
++        public override bool CanConvert(Type typeToConvert);
++        public abstract T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options);
++        public abstract void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options);
++    }
++    public class JsonConverterAttribute : JsonAttribute {
++        protected JsonConverterAttribute();
++        public JsonConverterAttribute(Type converterType);
++        public Type ConverterType { get; }
++        public virtual JsonConverter CreateConverter(Type typeToConvert);
++    }
++    public abstract class JsonConverterFactory : JsonConverter {
++        protected JsonConverterFactory();
++        public abstract JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options);
++    }
++    public sealed class JsonExtensionDataAttribute : JsonAttribute {
++        public JsonExtensionDataAttribute();
++    }
++    public sealed class JsonIgnoreAttribute : JsonAttribute {
++        public JsonIgnoreAttribute();
++    }
++    public sealed class JsonPropertyNameAttribute : JsonAttribute {
++        public JsonPropertyNameAttribute(string name);
++        public string Name { get; }
++    }
++    public sealed class JsonStringEnumConverter : JsonConverterFactory {
++        public JsonStringEnumConverter();
++        public JsonStringEnumConverter(JsonNamingPolicy namingPolicy = null, bool allowIntegerValues = true);
++        public override bool CanConvert(Type typeToConvert);
++        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options);
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Text.Json.md

@@ -0,0 +1,385 @@
+# System.Text.Json
+
+``` diff
++namespace System.Text.Json {
++    public enum JsonCommentHandling : byte {
++        Allow = (byte)2,
++        Disallow = (byte)0,
++        Skip = (byte)1,
++    }
++    public sealed class JsonDocument : IDisposable {
++        public JsonElement RootElement { get; }
++        public void Dispose();
++        public static JsonDocument Parse(ReadOnlySequence<byte> utf8Json, JsonDocumentOptions options = default(JsonDocumentOptions));
++        public static JsonDocument Parse(Stream utf8Json, JsonDocumentOptions options = default(JsonDocumentOptions));
++        public static JsonDocument Parse(ReadOnlyMemory<byte> utf8Json, JsonDocumentOptions options = default(JsonDocumentOptions));
++        public static JsonDocument Parse(ReadOnlyMemory<char> json, JsonDocumentOptions options = default(JsonDocumentOptions));
++        public static JsonDocument Parse(string json, JsonDocumentOptions options = default(JsonDocumentOptions));
++        public static Task<JsonDocument> ParseAsync(Stream utf8Json, JsonDocumentOptions options = default(JsonDocumentOptions), CancellationToken cancellationToken = default(CancellationToken));
++        public static JsonDocument ParseValue(ref Utf8JsonReader reader);
++        public static bool TryParseValue(ref Utf8JsonReader reader, out JsonDocument document);
++        public void WriteTo(Utf8JsonWriter writer);
++    }
++    public struct JsonDocumentOptions {
++        public bool AllowTrailingCommas { get; set; }
++        public JsonCommentHandling CommentHandling { get; set; }
++        public int MaxDepth { get; set; }
++    }
++    public readonly struct JsonElement {
++        public JsonElement this[int index] { get; }
++        public JsonValueKind ValueKind { get; }
++        public JsonElement Clone();
++        public JsonElement.ArrayEnumerator EnumerateArray();
++        public JsonElement.ObjectEnumerator EnumerateObject();
++        public int GetArrayLength();
++        public bool GetBoolean();
++        public byte GetByte();
++        public byte[] GetBytesFromBase64();
++        public DateTime GetDateTime();
++        public DateTimeOffset GetDateTimeOffset();
++        public decimal GetDecimal();
++        public double GetDouble();
++        public Guid GetGuid();
++        public short GetInt16();
++        public int GetInt32();
++        public long GetInt64();
++        public JsonElement GetProperty(ReadOnlySpan<byte> utf8PropertyName);
++        public JsonElement GetProperty(ReadOnlySpan<char> propertyName);
++        public JsonElement GetProperty(string propertyName);
++        public string GetRawText();
++        public sbyte GetSByte();
++        public float GetSingle();
++        public string GetString();
++        public ushort GetUInt16();
++        public uint GetUInt32();
++        public ulong GetUInt64();
++        public override string ToString();
++        public bool TryGetByte(out byte value);
++        public bool TryGetBytesFromBase64(out byte[] value);
++        public bool TryGetDateTime(out DateTime value);
++        public bool TryGetDateTimeOffset(out DateTimeOffset value);
++        public bool TryGetDecimal(out decimal value);
++        public bool TryGetDouble(out double value);
++        public bool TryGetGuid(out Guid value);
++        public bool TryGetInt16(out short value);
++        public bool TryGetInt32(out int value);
++        public bool TryGetInt64(out long value);
++        public bool TryGetProperty(ReadOnlySpan<byte> utf8PropertyName, out JsonElement value);
++        public bool TryGetProperty(ReadOnlySpan<char> propertyName, out JsonElement value);
++        public bool TryGetProperty(string propertyName, out JsonElement value);
++        public bool TryGetSByte(out sbyte value);
++        public bool TryGetSingle(out float value);
++        public bool TryGetUInt16(out ushort value);
++        public bool TryGetUInt32(out uint value);
++        public bool TryGetUInt64(out ulong value);
++        public bool ValueEquals(ReadOnlySpan<byte> utf8Text);
++        public bool ValueEquals(ReadOnlySpan<char> text);
++        public bool ValueEquals(string text);
++        public void WriteTo(Utf8JsonWriter writer);
++        public struct ArrayEnumerator : IDisposable, IEnumerable, IEnumerable<JsonElement>, IEnumerator, IEnumerator<JsonElement> {
++            public JsonElement Current { get; }
++            object System.Collections.IEnumerator.Current { get; }
++            public void Dispose();
++            public JsonElement.ArrayEnumerator GetEnumerator();
++            public bool MoveNext();
++            public void Reset();
++            IEnumerator<JsonElement> System.Collections.Generic.IEnumerable<System.Text.Json.JsonElement>.GetEnumerator();
++            IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        }
++        public struct ObjectEnumerator : IDisposable, IEnumerable, IEnumerable<JsonProperty>, IEnumerator, IEnumerator<JsonProperty> {
++            public JsonProperty Current { get; }
++            object System.Collections.IEnumerator.Current { get; }
++            public void Dispose();
++            public JsonElement.ObjectEnumerator GetEnumerator();
++            public bool MoveNext();
++            public void Reset();
++            IEnumerator<JsonProperty> System.Collections.Generic.IEnumerable<System.Text.Json.JsonProperty>.GetEnumerator();
++            IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        }
++    }
++    public readonly struct JsonEncodedText : IEquatable<JsonEncodedText> {
++        public ReadOnlySpan<byte> EncodedUtf8Bytes { get; }
++        public static JsonEncodedText Encode(ReadOnlySpan<byte> utf8Value, JavaScriptEncoder encoder = null);
++        public static JsonEncodedText Encode(ReadOnlySpan<char> value, JavaScriptEncoder encoder = null);
++        public static JsonEncodedText Encode(string value, JavaScriptEncoder encoder = null);
++        public override bool Equals(object obj);
++        public bool Equals(JsonEncodedText other);
++        public override int GetHashCode();
++        public override string ToString();
++    }
++    public class JsonException : Exception {
++        public JsonException();
++        protected JsonException(SerializationInfo info, StreamingContext context);
++        public JsonException(string message);
++        public JsonException(string message, Exception innerException);
++        public JsonException(string message, string path, long? lineNumber, long? bytePositionInLine);
++        public JsonException(string message, string path, long? lineNumber, long? bytePositionInLine, Exception innerException);
++        public long? BytePositionInLine { get; }
++        public long? LineNumber { get; }
++        public override string Message { get; }
++        public string Path { get; }
++        public override void GetObjectData(SerializationInfo info, StreamingContext context);
++    }
++    public abstract class JsonNamingPolicy {
++        protected JsonNamingPolicy();
++        public static JsonNamingPolicy CamelCase { get; }
++        public abstract string ConvertName(string name);
++    }
++    public readonly struct JsonProperty {
++        public string Name { get; }
++        public JsonElement Value { get; }
++        public bool NameEquals(ReadOnlySpan<byte> utf8Text);
++        public bool NameEquals(ReadOnlySpan<char> text);
++        public bool NameEquals(string text);
++        public override string ToString();
++        public void WriteTo(Utf8JsonWriter writer);
++    }
++    public struct JsonReaderOptions {
++        public bool AllowTrailingCommas { get; set; }
++        public JsonCommentHandling CommentHandling { get; set; }
++        public int MaxDepth { get; set; }
++    }
++    public struct JsonReaderState {
++        public JsonReaderState(JsonReaderOptions options = default(JsonReaderOptions));
++        public JsonReaderOptions Options { get; }
++    }
++    public static class JsonSerializer {
++        public static object Deserialize(ReadOnlySpan<byte> utf8Json, Type returnType, JsonSerializerOptions options = null);
++        public static object Deserialize(string json, Type returnType, JsonSerializerOptions options = null);
++        public static object Deserialize(ref Utf8JsonReader reader, Type returnType, JsonSerializerOptions options = null);
++        public static TValue Deserialize<TValue>(ReadOnlySpan<byte> utf8Json, JsonSerializerOptions options = null);
++        public static TValue Deserialize<TValue>(string json, JsonSerializerOptions options = null);
++        public static TValue Deserialize<TValue>(ref Utf8JsonReader reader, JsonSerializerOptions options = null);
++        public static ValueTask<object> DeserializeAsync(Stream utf8Json, Type returnType, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static ValueTask<TValue> DeserializeAsync<TValue>(Stream utf8Json, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static string Serialize(object value, Type inputType, JsonSerializerOptions options = null);
++        public static void Serialize(Utf8JsonWriter writer, object value, Type inputType, JsonSerializerOptions options = null);
++        public static void Serialize<TValue>(Utf8JsonWriter writer, TValue value, JsonSerializerOptions options = null);
++        public static string Serialize<TValue>(TValue value, JsonSerializerOptions options = null);
++        public static Task SerializeAsync(Stream utf8Json, object value, Type inputType, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static Task SerializeAsync<TValue>(Stream utf8Json, TValue value, JsonSerializerOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static byte[] SerializeToUtf8Bytes(object value, Type inputType, JsonSerializerOptions options = null);
++        public static byte[] SerializeToUtf8Bytes<TValue>(TValue value, JsonSerializerOptions options = null);
++    }
++    public sealed class JsonSerializerOptions {
++        public JsonSerializerOptions();
++        public bool AllowTrailingCommas { get; set; }
++        public IList<JsonConverter> Converters { get; }
++        public int DefaultBufferSize { get; set; }
++        public JsonNamingPolicy DictionaryKeyPolicy { get; set; }
++        public JavaScriptEncoder Encoder { get; set; }
++        public bool IgnoreNullValues { get; set; }
++        public bool IgnoreReadOnlyProperties { get; set; }
++        public int MaxDepth { get; set; }
++        public bool PropertyNameCaseInsensitive { get; set; }
++        public JsonNamingPolicy PropertyNamingPolicy { get; set; }
++        public JsonCommentHandling ReadCommentHandling { get; set; }
++        public bool WriteIndented { get; set; }
++        public JsonConverter GetConverter(Type typeToConvert);
++    }
++    public enum JsonTokenType : byte {
++        Comment = (byte)6,
++        EndArray = (byte)4,
++        EndObject = (byte)2,
++        False = (byte)10,
++        None = (byte)0,
++        Null = (byte)11,
++        Number = (byte)8,
++        PropertyName = (byte)5,
++        StartArray = (byte)3,
++        StartObject = (byte)1,
++        String = (byte)7,
++        True = (byte)9,
++    }
++    public enum JsonValueKind : byte {
++        Array = (byte)2,
++        False = (byte)6,
++        Null = (byte)7,
++        Number = (byte)4,
++        Object = (byte)1,
++        String = (byte)3,
++        True = (byte)5,
++        Undefined = (byte)0,
++    }
++    public struct JsonWriterOptions {
++        public JavaScriptEncoder Encoder { get; set; }
++        public bool Indented { get; set; }
++        public bool SkipValidation { get; set; }
++    }
++    public ref struct Utf8JsonReader {
++        public Utf8JsonReader(ReadOnlySequence<byte> jsonData, bool isFinalBlock, JsonReaderState state);
++        public Utf8JsonReader(ReadOnlySequence<byte> jsonData, JsonReaderOptions options = default(JsonReaderOptions));
++        public Utf8JsonReader(ReadOnlySpan<byte> jsonData, bool isFinalBlock, JsonReaderState state);
++        public Utf8JsonReader(ReadOnlySpan<byte> jsonData, JsonReaderOptions options = default(JsonReaderOptions));
++        public long BytesConsumed { get; }
++        public int CurrentDepth { get; }
++        public JsonReaderState CurrentState { get; }
++        public bool HasValueSequence { get; }
++        public bool IsFinalBlock { get; }
++        public SequencePosition Position { get; }
++        public long TokenStartIndex { get; }
++        public JsonTokenType TokenType { get; }
++        public ReadOnlySequence<byte> ValueSequence { get; }
++        public ReadOnlySpan<byte> ValueSpan { get; }
++        public bool GetBoolean();
++        public byte GetByte();
++        public byte[] GetBytesFromBase64();
++        public string GetComment();
++        public DateTime GetDateTime();
++        public DateTimeOffset GetDateTimeOffset();
++        public decimal GetDecimal();
++        public double GetDouble();
++        public Guid GetGuid();
++        public short GetInt16();
++        public int GetInt32();
++        public long GetInt64();
++        public sbyte GetSByte();
++        public float GetSingle();
++        public string GetString();
++        public ushort GetUInt16();
++        public uint GetUInt32();
++        public ulong GetUInt64();
++        public bool Read();
++        public void Skip();
++        public bool TryGetByte(out byte value);
++        public bool TryGetBytesFromBase64(out byte[] value);
++        public bool TryGetDateTime(out DateTime value);
++        public bool TryGetDateTimeOffset(out DateTimeOffset value);
++        public bool TryGetDecimal(out decimal value);
++        public bool TryGetDouble(out double value);
++        public bool TryGetGuid(out Guid value);
++        public bool TryGetInt16(out short value);
++        public bool TryGetInt32(out int value);
++        public bool TryGetInt64(out long value);
++        public bool TryGetSByte(out sbyte value);
++        public bool TryGetSingle(out float value);
++        public bool TryGetUInt16(out ushort value);
++        public bool TryGetUInt32(out uint value);
++        public bool TryGetUInt64(out ulong value);
++        public bool TrySkip();
++        public bool ValueTextEquals(ReadOnlySpan<byte> utf8Text);
++        public bool ValueTextEquals(ReadOnlySpan<char> text);
++        public bool ValueTextEquals(string text);
++    }
++    public sealed class Utf8JsonWriter : IAsyncDisposable, IDisposable {
++        public Utf8JsonWriter(IBufferWriter<byte> bufferWriter, JsonWriterOptions options = default(JsonWriterOptions));
++        public Utf8JsonWriter(Stream utf8Json, JsonWriterOptions options = default(JsonWriterOptions));
++        public long BytesCommitted { get; }
++        public int BytesPending { get; }
++        public int CurrentDepth { get; }
++        public JsonWriterOptions Options { get; }
++        public void Dispose();
++        public ValueTask DisposeAsync();
++        public void Flush();
++        public Task FlushAsync(CancellationToken cancellationToken = default(CancellationToken));
++        public void Reset();
++        public void Reset(IBufferWriter<byte> bufferWriter);
++        public void Reset(Stream utf8Json);
++        public void WriteBase64String(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> bytes);
++        public void WriteBase64String(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> bytes);
++        public void WriteBase64String(string propertyName, ReadOnlySpan<byte> bytes);
++        public void WriteBase64String(JsonEncodedText propertyName, ReadOnlySpan<byte> bytes);
++        public void WriteBase64StringValue(ReadOnlySpan<byte> bytes);
++        public void WriteBoolean(ReadOnlySpan<byte> utf8PropertyName, bool value);
++        public void WriteBoolean(ReadOnlySpan<char> propertyName, bool value);
++        public void WriteBoolean(string propertyName, bool value);
++        public void WriteBoolean(JsonEncodedText propertyName, bool value);
++        public void WriteBooleanValue(bool value);
++        public void WriteCommentValue(ReadOnlySpan<byte> utf8Value);
++        public void WriteCommentValue(ReadOnlySpan<char> value);
++        public void WriteCommentValue(string value);
++        public void WriteEndArray();
++        public void WriteEndObject();
++        public void WriteNull(ReadOnlySpan<byte> utf8PropertyName);
++        public void WriteNull(ReadOnlySpan<char> propertyName);
++        public void WriteNull(string propertyName);
++        public void WriteNull(JsonEncodedText propertyName);
++        public void WriteNullValue();
++        public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, decimal value);
++        public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, double value);
++        public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, int value);
++        public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, long value);
++        public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, float value);
++        public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, uint value);
++        public void WriteNumber(ReadOnlySpan<byte> utf8PropertyName, ulong value);
++        public void WriteNumber(ReadOnlySpan<char> propertyName, decimal value);
++        public void WriteNumber(ReadOnlySpan<char> propertyName, double value);
++        public void WriteNumber(ReadOnlySpan<char> propertyName, int value);
++        public void WriteNumber(ReadOnlySpan<char> propertyName, long value);
++        public void WriteNumber(ReadOnlySpan<char> propertyName, float value);
++        public void WriteNumber(ReadOnlySpan<char> propertyName, uint value);
++        public void WriteNumber(ReadOnlySpan<char> propertyName, ulong value);
++        public void WriteNumber(string propertyName, decimal value);
++        public void WriteNumber(string propertyName, double value);
++        public void WriteNumber(string propertyName, int value);
++        public void WriteNumber(string propertyName, long value);
++        public void WriteNumber(string propertyName, float value);
++        public void WriteNumber(string propertyName, uint value);
++        public void WriteNumber(string propertyName, ulong value);
++        public void WriteNumber(JsonEncodedText propertyName, decimal value);
++        public void WriteNumber(JsonEncodedText propertyName, double value);
++        public void WriteNumber(JsonEncodedText propertyName, int value);
++        public void WriteNumber(JsonEncodedText propertyName, long value);
++        public void WriteNumber(JsonEncodedText propertyName, float value);
++        public void WriteNumber(JsonEncodedText propertyName, uint value);
++        public void WriteNumber(JsonEncodedText propertyName, ulong value);
++        public void WriteNumberValue(decimal value);
++        public void WriteNumberValue(double value);
++        public void WriteNumberValue(int value);
++        public void WriteNumberValue(long value);
++        public void WriteNumberValue(float value);
++        public void WriteNumberValue(uint value);
++        public void WriteNumberValue(ulong value);
++        public void WritePropertyName(ReadOnlySpan<byte> utf8PropertyName);
++        public void WritePropertyName(ReadOnlySpan<char> propertyName);
++        public void WritePropertyName(string propertyName);
++        public void WritePropertyName(JsonEncodedText propertyName);
++        public void WriteStartArray();
++        public void WriteStartArray(ReadOnlySpan<byte> utf8PropertyName);
++        public void WriteStartArray(ReadOnlySpan<char> propertyName);
++        public void WriteStartArray(string propertyName);
++        public void WriteStartArray(JsonEncodedText propertyName);
++        public void WriteStartObject();
++        public void WriteStartObject(ReadOnlySpan<byte> utf8PropertyName);
++        public void WriteStartObject(ReadOnlySpan<char> propertyName);
++        public void WriteStartObject(string propertyName);
++        public void WriteStartObject(JsonEncodedText propertyName);
++        public void WriteString(ReadOnlySpan<byte> utf8PropertyName, DateTime value);
++        public void WriteString(ReadOnlySpan<byte> utf8PropertyName, DateTimeOffset value);
++        public void WriteString(ReadOnlySpan<byte> utf8PropertyName, Guid value);
++        public void WriteString(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<byte> utf8Value);
++        public void WriteString(ReadOnlySpan<byte> utf8PropertyName, ReadOnlySpan<char> value);
++        public void WriteString(ReadOnlySpan<byte> utf8PropertyName, string value);
++        public void WriteString(ReadOnlySpan<byte> utf8PropertyName, JsonEncodedText value);
++        public void WriteString(ReadOnlySpan<char> propertyName, DateTime value);
++        public void WriteString(ReadOnlySpan<char> propertyName, DateTimeOffset value);
++        public void WriteString(ReadOnlySpan<char> propertyName, Guid value);
++        public void WriteString(ReadOnlySpan<char> propertyName, ReadOnlySpan<byte> utf8Value);
++        public void WriteString(ReadOnlySpan<char> propertyName, ReadOnlySpan<char> value);
++        public void WriteString(ReadOnlySpan<char> propertyName, string value);
++        public void WriteString(ReadOnlySpan<char> propertyName, JsonEncodedText value);
++        public void WriteString(string propertyName, DateTime value);
++        public void WriteString(string propertyName, DateTimeOffset value);
++        public void WriteString(string propertyName, Guid value);
++        public void WriteString(string propertyName, ReadOnlySpan<byte> utf8Value);
++        public void WriteString(string propertyName, ReadOnlySpan<char> value);
++        public void WriteString(string propertyName, string value);
++        public void WriteString(string propertyName, JsonEncodedText value);
++        public void WriteString(JsonEncodedText propertyName, DateTime value);
++        public void WriteString(JsonEncodedText propertyName, DateTimeOffset value);
++        public void WriteString(JsonEncodedText propertyName, Guid value);
++        public void WriteString(JsonEncodedText propertyName, ReadOnlySpan<byte> utf8Value);
++        public void WriteString(JsonEncodedText propertyName, ReadOnlySpan<char> value);
++        public void WriteString(JsonEncodedText propertyName, string value);
++        public void WriteString(JsonEncodedText propertyName, JsonEncodedText value);
++        public void WriteStringValue(DateTime value);
++        public void WriteStringValue(DateTimeOffset value);
++        public void WriteStringValue(Guid value);
++        public void WriteStringValue(ReadOnlySpan<byte> utf8Value);
++        public void WriteStringValue(ReadOnlySpan<char> value);
++        public void WriteStringValue(string value);
++        public void WriteStringValue(JsonEncodedText value);
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Text.RegularExpressions.md

@@ -0,0 +1,15 @@
+# System.Text.RegularExpressions
+
+``` diff
+ namespace System.Text.RegularExpressions {
+-    public class GroupCollection : ICollection, ICollection<Group>, IEnumerable, IEnumerable<Group>, IList, IList<Group>, IReadOnlyCollection<Group>, IReadOnlyList<Group> {
++    public class GroupCollection : ICollection, ICollection<Group>, IEnumerable, IEnumerable<Group>, IEnumerable<KeyValuePair<string, Group>>, IList, IList<Group>, IReadOnlyCollection<Group>, IReadOnlyCollection<KeyValuePair<string, Group>>, IReadOnlyDictionary<string, Group>, IReadOnlyList<Group> {
++        public IEnumerable<string> Keys { get; }
++        public IEnumerable<Group> Values { get; }
++        public bool ContainsKey(string key);
++        IEnumerator<KeyValuePair<string, Group>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.String,System.Text.RegularExpressions.Group>>.GetEnumerator();
++        public bool TryGetValue(string key, out Group value);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Text.Unicode.md

@@ -0,0 +1,180 @@
+# System.Text.Unicode
+
+``` diff
++namespace System.Text.Unicode {
++    public sealed class UnicodeRange {
++        public UnicodeRange(int firstCodePoint, int length);
++        public int FirstCodePoint { get; }
++        public int Length { get; }
++        public static UnicodeRange Create(char firstCharacter, char lastCharacter);
++    }
++    public static class UnicodeRanges {
++        public static UnicodeRange All { get; }
++        public static UnicodeRange AlphabeticPresentationForms { get; }
++        public static UnicodeRange Arabic { get; }
++        public static UnicodeRange ArabicExtendedA { get; }
++        public static UnicodeRange ArabicPresentationFormsA { get; }
++        public static UnicodeRange ArabicPresentationFormsB { get; }
++        public static UnicodeRange ArabicSupplement { get; }
++        public static UnicodeRange Armenian { get; }
++        public static UnicodeRange Arrows { get; }
++        public static UnicodeRange Balinese { get; }
++        public static UnicodeRange Bamum { get; }
++        public static UnicodeRange BasicLatin { get; }
++        public static UnicodeRange Batak { get; }
++        public static UnicodeRange Bengali { get; }
++        public static UnicodeRange BlockElements { get; }
++        public static UnicodeRange Bopomofo { get; }
++        public static UnicodeRange BopomofoExtended { get; }
++        public static UnicodeRange BoxDrawing { get; }
++        public static UnicodeRange BraillePatterns { get; }
++        public static UnicodeRange Buginese { get; }
++        public static UnicodeRange Buhid { get; }
++        public static UnicodeRange Cham { get; }
++        public static UnicodeRange Cherokee { get; }
++        public static UnicodeRange CherokeeSupplement { get; }
++        public static UnicodeRange CjkCompatibility { get; }
++        public static UnicodeRange CjkCompatibilityForms { get; }
++        public static UnicodeRange CjkCompatibilityIdeographs { get; }
++        public static UnicodeRange CjkRadicalsSupplement { get; }
++        public static UnicodeRange CjkStrokes { get; }
++        public static UnicodeRange CjkSymbolsandPunctuation { get; }
++        public static UnicodeRange CjkUnifiedIdeographs { get; }
++        public static UnicodeRange CjkUnifiedIdeographsExtensionA { get; }
++        public static UnicodeRange CombiningDiacriticalMarks { get; }
++        public static UnicodeRange CombiningDiacriticalMarksExtended { get; }
++        public static UnicodeRange CombiningDiacriticalMarksforSymbols { get; }
++        public static UnicodeRange CombiningDiacriticalMarksSupplement { get; }
++        public static UnicodeRange CombiningHalfMarks { get; }
++        public static UnicodeRange CommonIndicNumberForms { get; }
++        public static UnicodeRange ControlPictures { get; }
++        public static UnicodeRange Coptic { get; }
++        public static UnicodeRange CurrencySymbols { get; }
++        public static UnicodeRange Cyrillic { get; }
++        public static UnicodeRange CyrillicExtendedA { get; }
++        public static UnicodeRange CyrillicExtendedB { get; }
++        public static UnicodeRange CyrillicExtendedC { get; }
++        public static UnicodeRange CyrillicSupplement { get; }
++        public static UnicodeRange Devanagari { get; }
++        public static UnicodeRange DevanagariExtended { get; }
++        public static UnicodeRange Dingbats { get; }
++        public static UnicodeRange EnclosedAlphanumerics { get; }
++        public static UnicodeRange EnclosedCjkLettersandMonths { get; }
++        public static UnicodeRange Ethiopic { get; }
++        public static UnicodeRange EthiopicExtended { get; }
++        public static UnicodeRange EthiopicExtendedA { get; }
++        public static UnicodeRange EthiopicSupplement { get; }
++        public static UnicodeRange GeneralPunctuation { get; }
++        public static UnicodeRange GeometricShapes { get; }
++        public static UnicodeRange Georgian { get; }
++        public static UnicodeRange GeorgianExtended { get; }
++        public static UnicodeRange GeorgianSupplement { get; }
++        public static UnicodeRange Glagolitic { get; }
++        public static UnicodeRange GreekandCoptic { get; }
++        public static UnicodeRange GreekExtended { get; }
++        public static UnicodeRange Gujarati { get; }
++        public static UnicodeRange Gurmukhi { get; }
++        public static UnicodeRange HalfwidthandFullwidthForms { get; }
++        public static UnicodeRange HangulCompatibilityJamo { get; }
++        public static UnicodeRange HangulJamo { get; }
++        public static UnicodeRange HangulJamoExtendedA { get; }
++        public static UnicodeRange HangulJamoExtendedB { get; }
++        public static UnicodeRange HangulSyllables { get; }
++        public static UnicodeRange Hanunoo { get; }
++        public static UnicodeRange Hebrew { get; }
++        public static UnicodeRange Hiragana { get; }
++        public static UnicodeRange IdeographicDescriptionCharacters { get; }
++        public static UnicodeRange IpaExtensions { get; }
++        public static UnicodeRange Javanese { get; }
++        public static UnicodeRange Kanbun { get; }
++        public static UnicodeRange KangxiRadicals { get; }
++        public static UnicodeRange Kannada { get; }
++        public static UnicodeRange Katakana { get; }
++        public static UnicodeRange KatakanaPhoneticExtensions { get; }
++        public static UnicodeRange KayahLi { get; }
++        public static UnicodeRange Khmer { get; }
++        public static UnicodeRange KhmerSymbols { get; }
++        public static UnicodeRange Lao { get; }
++        public static UnicodeRange Latin1Supplement { get; }
++        public static UnicodeRange LatinExtendedA { get; }
++        public static UnicodeRange LatinExtendedAdditional { get; }
++        public static UnicodeRange LatinExtendedB { get; }
++        public static UnicodeRange LatinExtendedC { get; }
++        public static UnicodeRange LatinExtendedD { get; }
++        public static UnicodeRange LatinExtendedE { get; }
++        public static UnicodeRange Lepcha { get; }
++        public static UnicodeRange LetterlikeSymbols { get; }
++        public static UnicodeRange Limbu { get; }
++        public static UnicodeRange Lisu { get; }
++        public static UnicodeRange Malayalam { get; }
++        public static UnicodeRange Mandaic { get; }
++        public static UnicodeRange MathematicalOperators { get; }
++        public static UnicodeRange MeeteiMayek { get; }
++        public static UnicodeRange MeeteiMayekExtensions { get; }
++        public static UnicodeRange MiscellaneousMathematicalSymbolsA { get; }
++        public static UnicodeRange MiscellaneousMathematicalSymbolsB { get; }
++        public static UnicodeRange MiscellaneousSymbols { get; }
++        public static UnicodeRange MiscellaneousSymbolsandArrows { get; }
++        public static UnicodeRange MiscellaneousTechnical { get; }
++        public static UnicodeRange ModifierToneLetters { get; }
++        public static UnicodeRange Mongolian { get; }
++        public static UnicodeRange Myanmar { get; }
++        public static UnicodeRange MyanmarExtendedA { get; }
++        public static UnicodeRange MyanmarExtendedB { get; }
++        public static UnicodeRange NewTaiLue { get; }
++        public static UnicodeRange NKo { get; }
++        public static UnicodeRange None { get; }
++        public static UnicodeRange NumberForms { get; }
++        public static UnicodeRange Ogham { get; }
++        public static UnicodeRange OlChiki { get; }
++        public static UnicodeRange OpticalCharacterRecognition { get; }
++        public static UnicodeRange Oriya { get; }
++        public static UnicodeRange Phagspa { get; }
++        public static UnicodeRange PhoneticExtensions { get; }
++        public static UnicodeRange PhoneticExtensionsSupplement { get; }
++        public static UnicodeRange Rejang { get; }
++        public static UnicodeRange Runic { get; }
++        public static UnicodeRange Samaritan { get; }
++        public static UnicodeRange Saurashtra { get; }
++        public static UnicodeRange Sinhala { get; }
++        public static UnicodeRange SmallFormVariants { get; }
++        public static UnicodeRange SpacingModifierLetters { get; }
++        public static UnicodeRange Specials { get; }
++        public static UnicodeRange Sundanese { get; }
++        public static UnicodeRange SundaneseSupplement { get; }
++        public static UnicodeRange SuperscriptsandSubscripts { get; }
++        public static UnicodeRange SupplementalArrowsA { get; }
++        public static UnicodeRange SupplementalArrowsB { get; }
++        public static UnicodeRange SupplementalMathematicalOperators { get; }
++        public static UnicodeRange SupplementalPunctuation { get; }
++        public static UnicodeRange SylotiNagri { get; }
++        public static UnicodeRange Syriac { get; }
++        public static UnicodeRange SyriacSupplement { get; }
++        public static UnicodeRange Tagalog { get; }
++        public static UnicodeRange Tagbanwa { get; }
++        public static UnicodeRange TaiLe { get; }
++        public static UnicodeRange TaiTham { get; }
++        public static UnicodeRange TaiViet { get; }
++        public static UnicodeRange Tamil { get; }
++        public static UnicodeRange Telugu { get; }
++        public static UnicodeRange Thaana { get; }
++        public static UnicodeRange Thai { get; }
++        public static UnicodeRange Tibetan { get; }
++        public static UnicodeRange Tifinagh { get; }
++        public static UnicodeRange UnifiedCanadianAboriginalSyllabics { get; }
++        public static UnicodeRange UnifiedCanadianAboriginalSyllabicsExtended { get; }
++        public static UnicodeRange Vai { get; }
++        public static UnicodeRange VariationSelectors { get; }
++        public static UnicodeRange VedicExtensions { get; }
++        public static UnicodeRange VerticalForms { get; }
++        public static UnicodeRange YijingHexagramSymbols { get; }
++        public static UnicodeRange YiRadicals { get; }
++        public static UnicodeRange YiSyllables { get; }
++    }
++    public static class Utf8 {
++        public static OperationStatus FromUtf16(ReadOnlySpan<char> source, Span<byte> destination, out int charsRead, out int bytesWritten, bool replaceInvalidSequences = true, bool isFinalBlock = true);
++        public static OperationStatus ToUtf16(ReadOnlySpan<byte> source, Span<char> destination, out int bytesRead, out int charsWritten, bool replaceInvalidSequences = true, bool isFinalBlock = true);
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Text.md

@@ -0,0 +1,115 @@
+# System.Text
+
+``` diff
+ namespace System.Text {
+     public class ASCIIEncoding : Encoding {
++        public override int GetByteCount(ReadOnlySpan<char> chars);
++        public override int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes);
++        public override int GetCharCount(ReadOnlySpan<byte> bytes);
++        public override int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars);
+     }
++    public sealed class CodePagesEncodingProvider : EncodingProvider {
++        public static EncodingProvider Instance { get; }
++        public override Encoding GetEncoding(int codepage);
++        public override Encoding GetEncoding(string name);
++    }
++    public readonly struct Rune : IComparable<Rune>, IEquatable<Rune> {
++        public Rune(char ch);
++        public Rune(char highSurrogate, char lowSurrogate);
++        public Rune(int value);
++        public Rune(uint value);
++        public bool IsAscii { get; }
++        public bool IsBmp { get; }
++        public int Plane { get; }
++        public static Rune ReplacementChar { get; }
++        public int Utf16SequenceLength { get; }
++        public int Utf8SequenceLength { get; }
++        public int Value { get; }
++        public int CompareTo(Rune other);
++        public static OperationStatus DecodeFromUtf16(ReadOnlySpan<char> source, out Rune result, out int charsConsumed);
++        public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> source, out Rune result, out int bytesConsumed);
++        public static OperationStatus DecodeLastFromUtf16(ReadOnlySpan<char> source, out Rune result, out int charsConsumed);
++        public static OperationStatus DecodeLastFromUtf8(ReadOnlySpan<byte> source, out Rune value, out int bytesConsumed);
++        public int EncodeToUtf16(Span<char> destination);
++        public int EncodeToUtf8(Span<byte> destination);
++        public override bool Equals(object obj);
++        public bool Equals(Rune other);
++        public override int GetHashCode();
++        public static double GetNumericValue(Rune value);
++        public static Rune GetRuneAt(string input, int index);
++        public static UnicodeCategory GetUnicodeCategory(Rune value);
++        public static bool IsControl(Rune value);
++        public static bool IsDigit(Rune value);
++        public static bool IsLetter(Rune value);
++        public static bool IsLetterOrDigit(Rune value);
++        public static bool IsLower(Rune value);
++        public static bool IsNumber(Rune value);
++        public static bool IsPunctuation(Rune value);
++        public static bool IsSeparator(Rune value);
++        public static bool IsSymbol(Rune value);
++        public static bool IsUpper(Rune value);
++        public static bool IsValid(int value);
++        public static bool IsValid(uint value);
++        public static bool IsWhiteSpace(Rune value);
++        public static bool operator ==(Rune left, Rune right);
++        public static explicit operator Rune (char ch);
++        public static explicit operator Rune (int value);
++        public static explicit operator Rune (uint value);
++        public static bool operator >(Rune left, Rune right);
++        public static bool operator >=(Rune left, Rune right);
++        public static bool operator !=(Rune left, Rune right);
++        public static bool operator <(Rune left, Rune right);
++        public static bool operator <=(Rune left, Rune right);
++        public static Rune ToLower(Rune value, CultureInfo culture);
++        public static Rune ToLowerInvariant(Rune value);
++        public override string ToString();
++        public static Rune ToUpper(Rune value, CultureInfo culture);
++        public static Rune ToUpperInvariant(Rune value);
++        public static bool TryCreate(char highSurrogate, char lowSurrogate, out Rune result);
++        public static bool TryCreate(char ch, out Rune result);
++        public static bool TryCreate(int value, out Rune result);
++        public static bool TryCreate(uint value, out Rune result);
++        public bool TryEncodeToUtf16(Span<char> destination, out int charsWritten);
++        public bool TryEncodeToUtf8(Span<byte> destination, out int bytesWritten);
++        public static bool TryGetRuneAt(string input, int index, out Rune value);
++    }
++    public ref struct SpanRuneEnumerator {
++        public Rune Current { get; }
++        public SpanRuneEnumerator GetEnumerator();
++        public bool MoveNext();
++    }
+     public sealed class StringBuilder : ISerializable {
++        public StringBuilder Append(ReadOnlyMemory<char> value);
++        public StringBuilder.ChunkEnumerator GetChunks();
++        public struct ChunkEnumerator {
++            public ReadOnlyMemory<char> Current { get; }
++            public StringBuilder.ChunkEnumerator GetEnumerator();
++            public bool MoveNext();
++        }
+     }
++    public struct StringRuneEnumerator : IDisposable, IEnumerable, IEnumerable<Rune>, IEnumerator, IEnumerator<Rune> {
++        public Rune Current { get; }
++        object System.Collections.IEnumerator.Current { get; }
++        public StringRuneEnumerator GetEnumerator();
++        public bool MoveNext();
++        IEnumerator<Rune> System.Collections.Generic.IEnumerable<System.Text.Rune>.GetEnumerator();
++        IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        void System.Collections.IEnumerator.Reset();
++        void System.IDisposable.Dispose();
++    }
+     public class UnicodeEncoding : Encoding {
++        public override ReadOnlySpan<byte> Preamble { get; }
+     }
+     public sealed class UTF32Encoding : Encoding {
++        public override ReadOnlySpan<byte> Preamble { get; }
+     }
+     public class UTF8Encoding : Encoding {
++        public override ReadOnlySpan<byte> Preamble { get; }
++        public override int GetByteCount(ReadOnlySpan<char> chars);
++        public override int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes);
++        public override int GetCharCount(ReadOnlySpan<byte> bytes);
++        public override int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars);
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Threading.Channels.md

@@ -0,0 +1,66 @@
+# System.Threading.Channels
+
+``` diff
++namespace System.Threading.Channels {
++    public enum BoundedChannelFullMode {
++        DropNewest = 1,
++        DropOldest = 2,
++        DropWrite = 3,
++        Wait = 0,
++    }
++    public sealed class BoundedChannelOptions : ChannelOptions {
++        public BoundedChannelOptions(int capacity);
++        public int Capacity { get; set; }
++        public BoundedChannelFullMode FullMode { get; set; }
++    }
++    public static class Channel {
++        public static Channel<T> CreateBounded<T>(int capacity);
++        public static Channel<T> CreateBounded<T>(BoundedChannelOptions options);
++        public static Channel<T> CreateUnbounded<T>();
++        public static Channel<T> CreateUnbounded<T>(UnboundedChannelOptions options);
++    }
++    public abstract class Channel<T> : Channel<T, T> {
++        protected Channel();
++    }
++    public abstract class Channel<TWrite, TRead> {
++        protected Channel();
++        public ChannelReader<TRead> Reader { get; protected set; }
++        public ChannelWriter<TWrite> Writer { get; protected set; }
++        public static implicit operator ChannelReader<TRead> (Channel<TWrite, TRead> channel);
++        public static implicit operator ChannelWriter<TWrite> (Channel<TWrite, TRead> channel);
++    }
++    public class ChannelClosedException : InvalidOperationException {
++        public ChannelClosedException();
++        public ChannelClosedException(Exception innerException);
++        protected ChannelClosedException(SerializationInfo info, StreamingContext context);
++        public ChannelClosedException(string message);
++        public ChannelClosedException(string message, Exception innerException);
++    }
++    public abstract class ChannelOptions {
++        protected ChannelOptions();
++        public bool AllowSynchronousContinuations { get; set; }
++        public bool SingleReader { get; set; }
++        public bool SingleWriter { get; set; }
++    }
++    public abstract class ChannelReader<T> {
++        protected ChannelReader();
++        public virtual Task Completion { get; }
++        public virtual IAsyncEnumerable<T> ReadAllAsync(CancellationToken cancellationToken = default(CancellationToken));
++        public virtual ValueTask<T> ReadAsync(CancellationToken cancellationToken = default(CancellationToken));
++        public abstract bool TryRead(out T item);
++        public abstract ValueTask<bool> WaitToReadAsync(CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public abstract class ChannelWriter<T> {
++        protected ChannelWriter();
++        public void Complete(Exception error = null);
++        public virtual bool TryComplete(Exception error = null);
++        public abstract bool TryWrite(T item);
++        public abstract ValueTask<bool> WaitToWriteAsync(CancellationToken cancellationToken = default(CancellationToken));
++        public virtual ValueTask WriteAsync(T item, CancellationToken cancellationToken = default(CancellationToken));
++    }
++    public sealed class UnboundedChannelOptions : ChannelOptions {
++        public UnboundedChannelOptions();
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Threading.Tasks.Sources.md

@@ -0,0 +1,17 @@
+# System.Threading.Tasks.Sources
+
+``` diff
+ namespace System.Threading.Tasks.Sources {
++    public struct ManualResetValueTaskSourceCore<TResult> {
++        public bool RunContinuationsAsynchronously { get; set; }
++        public short Version { get; }
++        public TResult GetResult(short token);
++        public ValueTaskSourceStatus GetStatus(short token);
++        public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags);
++        public void Reset();
++        public void SetException(Exception error);
++        public void SetResult(TResult result);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Threading.Tasks.md

@@ -0,0 +1,12 @@
+# System.Threading.Tasks
+
+``` diff
+ namespace System.Threading.Tasks {
++    public static class TaskAsyncEnumerableExtensions {
++        public static ConfiguredAsyncDisposable ConfigureAwait(this IAsyncDisposable source, bool continueOnCapturedContext);
++        public static ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait<T>(this IAsyncEnumerable<T> source, bool continueOnCapturedContext);
++        public static ConfiguredCancelableAsyncEnumerable<T> WithCancellation<T>(this IAsyncEnumerable<T> source, CancellationToken cancellationToken);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Threading.md

@@ -0,0 +1,45 @@
+# System.Threading
+
+``` diff
+ namespace System.Threading {
+-    public struct AsyncLocalValueChangedArgs<T>
++    public readonly struct AsyncLocalValueChangedArgs<T>
+     public readonly struct CancellationToken {
++        public CancellationTokenRegistration UnsafeRegister(Action<object> callback, object state);
+     }
+-    public readonly struct CancellationTokenRegistration : IDisposable, IEquatable<CancellationTokenRegistration> {
++    public readonly struct CancellationTokenRegistration : IAsyncDisposable, IDisposable, IEquatable<CancellationTokenRegistration> {
++        public ValueTask DisposeAsync();
++        public bool Unregister();
+     }
++    public interface IThreadPoolWorkItem {
++        void Execute();
++    }
+     public static class Monitor {
++        public static long LockContentionCount { get; }
+     }
+     public sealed class PreAllocatedOverlapped : IDisposable {
++        ~PreAllocatedOverlapped();
+     }
+     public sealed class ReaderWriterLock : CriticalFinalizerObject {
+-        ~ReaderWriterLock();
+
+     }
+     public struct SpinWait {
++        public void SpinOnce(int sleep1Threshold);
+     }
+     public static class ThreadPool {
++        public static long CompletedWorkItemCount { get; }
++        public static long PendingWorkItemCount { get; }
++        public static int ThreadCount { get; }
++        public static bool UnsafeQueueUserWorkItem(IThreadPoolWorkItem callBack, bool preferLocal);
++        public static bool UnsafeQueueUserWorkItem<TState>(Action<TState> callBack, TState state, bool preferLocal);
+     }
+-    public sealed class Timer : MarshalByRefObject, IDisposable {
++    public sealed class Timer : MarshalByRefObject, IAsyncDisposable, IDisposable {
++        public static long ActiveCount { get; }
++        public ValueTask DisposeAsync();
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Windows.Markup.md

@@ -0,0 +1,13 @@
+# System.Windows.Markup
+
+``` diff
++namespace System.Windows.Markup {
++    public sealed class ValueSerializerAttribute : Attribute {
++        public ValueSerializerAttribute(string valueSerializerTypeName);
++        public ValueSerializerAttribute(Type valueSerializerType);
++        public Type ValueSerializerType { get; }
++        public string ValueSerializerTypeName { get; }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Xml.Schema.md

@@ -0,0 +1,15 @@
+# System.Xml.Schema
+
+``` diff
+ namespace System.Xml.Schema {
+     public abstract class XmlSchemaDatatype {
+-        protected XmlSchemaDatatype();
+
+     }
+     public abstract class XmlSchemaGroupBase : XmlSchemaParticle {
+-        protected XmlSchemaGroupBase();
+
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.Xml.md

@@ -0,0 +1,24 @@
+# System.Xml
+
+``` diff
+ namespace System.Xml {
++    public class XmlDataDocument : XmlDocument {
++        public XmlDataDocument();
++        public XmlDataDocument(DataSet dataset);
++        public DataSet DataSet { get; }
++        public override XmlNode CloneNode(bool deep);
++        public override XmlElement CreateElement(string prefix, string localName, string namespaceURI);
++        public override XmlEntityReference CreateEntityReference(string name);
++        protected override XPathNavigator CreateNavigator(XmlNode node);
++        public override XmlElement GetElementById(string elemId);
++        public XmlElement GetElementFromRow(DataRow r);
++        public override XmlNodeList GetElementsByTagName(string name);
++        public DataRow GetRowFromElement(XmlElement e);
++        public override void Load(Stream inStream);
++        public override void Load(TextReader txtReader);
++        public override void Load(string filename);
++        public override void Load(XmlReader reader);
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/3.0.0_System.md

@@ -0,0 +1,230 @@
+# System
+
+``` diff
+ namespace System {
+     public static class Activator {
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName);
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public static ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes);
+     }
+-    public class AppDomain : MarshalByRefObject {
++    public sealed class AppDomain : MarshalByRefObject {
++        public PermissionSet PermissionSet { get; }
++        public AppDomainSetup SetupInformation { get; }
++        public ObjectHandle CreateInstance(string assemblyName, string typeName);
++        public ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public object CreateInstanceAndUnwrap(string assemblyName, string typeName, object[] activationAttributes);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
++        public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, object[] activationAttributes);
+     }
++    public sealed class AppDomainSetup {
++        public string ApplicationBase { get; }
++        public string TargetFrameworkName { get; }
++    }
++    public ref struct ArgIterator {
++        public ArgIterator(RuntimeArgumentHandle arglist);
++        public unsafe ArgIterator(RuntimeArgumentHandle arglist, void* ptr);
++        public void End();
++        public override bool Equals(object o);
++        public override int GetHashCode();
++        public TypedReference GetNextArg();
++        public TypedReference GetNextArg(RuntimeTypeHandle rth);
++        public RuntimeTypeHandle GetNextArgType();
++        public int GetRemainingCount();
++    }
+-    public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
++    public readonly struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool>
+-    public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
++    public readonly struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable
+-    public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
++    public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
+-    public struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, ISerializable
++    public readonly struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, ISerializable
+-    public struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable
++    public readonly struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable
+-    public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
++    public readonly struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable
+     public static class Environment {
++        public static long TickCount64 { get; }
+     }
+     public class Exception : ISerializable {
+-        public int HResult { get; protected set; }
++        public int HResult { get; set; }
+     }
+     public abstract class FormattableString : IFormattable {
++        public static string CurrentCulture(FormattableString formattable);
+     }
+     public static class GC {
++        public static GCMemoryInfo GetGCMemoryInfo();
++        public static long GetTotalAllocatedBytes(bool precise = false);
+     }
++    public readonly struct GCMemoryInfo {
++        public long FragmentedBytes { get; }
++        public long HeapSizeBytes { get; }
++        public long HighMemoryLoadThresholdBytes { get; }
++        public long MemoryLoadBytes { get; }
++        public long TotalAvailableMemoryBytes { get; }
++    }
++    public interface IAsyncDisposable {
++        ValueTask DisposeAsync();
++    }
++    public readonly struct Index : IEquatable<Index> {
++        public Index(int value, bool fromEnd = false);
++        public static Index End { get; }
++        public bool IsFromEnd { get; }
++        public static Index Start { get; }
++        public int Value { get; }
++        public bool Equals(Index other);
++        public override bool Equals(object value);
++        public static Index FromEnd(int value);
++        public static Index FromStart(int value);
++        public override int GetHashCode();
++        public int GetOffset(int length);
++        public static implicit operator Index (int value);
++        public override string ToString();
++    }
+-    public struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable
++    public readonly struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable
+-    public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
++    public readonly struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
+-    public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
++    public readonly struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
+-    public struct IntPtr : IEquatable<IntPtr>, ISerializable
++    public readonly struct IntPtr : IEquatable<IntPtr>, ISerializable
+     public static class Math {
++        public static double BitDecrement(double x);
++        public static double BitIncrement(double x);
++        public static double CopySign(double x, double y);
++        public static double FusedMultiplyAdd(double x, double y, double z);
++        public static int ILogB(double x);
++        public static double Log2(double x);
++        public static double MaxMagnitude(double x, double y);
++        public static double MinMagnitude(double x, double y);
++        public static double ScaleB(double x, int n);
+     }
+     public static class MathF {
++        public static float BitDecrement(float x);
++        public static float BitIncrement(float x);
++        public static float CopySign(float x, float y);
++        public static float FusedMultiplyAdd(float x, float y, float z);
++        public static int ILogB(float x);
++        public static float Log2(float x);
++        public static float MaxMagnitude(float x, float y);
++        public static float MinMagnitude(float x, float y);
++        public static float ScaleB(float x, int n);
+     }
+-    public readonly struct Memory<T>
++    public readonly struct Memory<T> : IEquatable<Memory<T>>
+     public static class MemoryExtensions {
++        public static ReadOnlyMemory<char> AsMemory(this string text, Index startIndex);
++        public static ReadOnlyMemory<char> AsMemory(this string text, Range range);
++        public static Memory<T> AsMemory<T>(this T[] array, Index startIndex);
++        public static Memory<T> AsMemory<T>(this T[] array, Range range);
++        public static Span<T> AsSpan<T>(this ArraySegment<T> segment, Index startIndex);
++        public static Span<T> AsSpan<T>(this ArraySegment<T> segment, Range range);
++        public static Span<T> AsSpan<T>(this T[] array, Index startIndex);
++        public static Span<T> AsSpan<T>(this T[] array, Range range);
++        public static bool Contains<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>;
++        public static bool Contains<T>(this Span<T> span, T value) where T : IEquatable<T>;
++        public static SpanRuneEnumerator EnumerateRunes(this ReadOnlySpan<char> span);
++        public static SpanRuneEnumerator EnumerateRunes(this Span<char> span);
++        public static int LastIndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType);
++        public static Memory<char> Trim(this Memory<char> memory);
++        public static ReadOnlyMemory<char> Trim(this ReadOnlyMemory<char> memory);
++        public static Span<char> Trim(this Span<char> span);
++        public static Memory<T> Trim<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static Memory<T> Trim<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>;
++        public static ReadOnlyMemory<T> Trim<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static ReadOnlyMemory<T> Trim<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>;
++        public static ReadOnlySpan<T> Trim<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static ReadOnlySpan<T> Trim<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>;
++        public static Span<T> Trim<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static Span<T> Trim<T>(this Span<T> span, T trimElement) where T : IEquatable<T>;
++        public static Memory<char> TrimEnd(this Memory<char> memory);
++        public static ReadOnlyMemory<char> TrimEnd(this ReadOnlyMemory<char> memory);
++        public static Span<char> TrimEnd(this Span<char> span);
++        public static Memory<T> TrimEnd<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static Memory<T> TrimEnd<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>;
++        public static ReadOnlyMemory<T> TrimEnd<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static ReadOnlyMemory<T> TrimEnd<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>;
++        public static ReadOnlySpan<T> TrimEnd<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static ReadOnlySpan<T> TrimEnd<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>;
++        public static Span<T> TrimEnd<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static Span<T> TrimEnd<T>(this Span<T> span, T trimElement) where T : IEquatable<T>;
++        public static Memory<char> TrimStart(this Memory<char> memory);
++        public static ReadOnlyMemory<char> TrimStart(this ReadOnlyMemory<char> memory);
++        public static Span<char> TrimStart(this Span<char> span);
++        public static Memory<T> TrimStart<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static Memory<T> TrimStart<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>;
++        public static ReadOnlyMemory<T> TrimStart<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static ReadOnlyMemory<T> TrimStart<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>;
++        public static ReadOnlySpan<T> TrimStart<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static ReadOnlySpan<T> TrimStart<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>;
++        public static Span<T> TrimStart<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
++        public static Span<T> TrimStart<T>(this Span<T> span, T trimElement) where T : IEquatable<T>;
+     }
+     public enum MidpointRounding {
++        ToNegativeInfinity = 3,
++        ToPositiveInfinity = 4,
++        ToZero = 2,
+     }
++    public readonly struct Range : IEquatable<Range> {
++        public Range(Index start, Index end);
++        public static Range All { get; }
++        public Index End { get; }
++        public Index Start { get; }
++        public static Range EndAt(Index end);
++        public override bool Equals(object value);
++        public bool Equals(Range other);
++        public override int GetHashCode();
++        public (int Offset, int Length) GetOffsetAndLength(int length);
++        public static Range StartAt(Index start);
++        public override string ToString();
++    }
+-    public readonly struct ReadOnlyMemory<T>
++    public readonly struct ReadOnlyMemory<T> : IEquatable<ReadOnlyMemory<T>>
+-    public struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable
++    public readonly struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable
+-    public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
++    public readonly struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
+     public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEnumerable, IEnumerable<char>, IEquatable<string> {
++        public static String Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1);
++        public static String Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2);
++        public static String Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3);
++        public StringRuneEnumerator EnumerateRunes();
++        public static int GetHashCode(ReadOnlySpan<char> value);
++        public static int GetHashCode(ReadOnlySpan<char> value, StringComparison comparisonType);
++        public ref readonly char GetPinnableReference();
+     }
+     public abstract class StringComparer : IComparer, IComparer<string>, IEqualityComparer, IEqualityComparer<string> {
+-        bool System.Collections.IEqualityComparer.Equals(object x, object y);
+
+-        int System.Collections.IEqualityComparer.GetHashCode(object obj);
+
+     }
+-    public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
++    public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable
+     public abstract class Type : MemberInfo, IReflect {
++        public static Type MakeGenericSignatureType(Type genericTypeDefinition, params Type[] typeArguments);
+     }
+-    public struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable
++    public readonly struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable
+-    public struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable
++    public readonly struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable
+-    public struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable
++    public readonly struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable
+-    public struct UIntPtr : IEquatable<UIntPtr>, ISerializable
++    public readonly struct UIntPtr : IEquatable<UIntPtr>, ISerializable
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/README.md

@@ -0,0 +1,6 @@
+# .NET Core 3.0 API Changes
+
+The following API changes were made in .NET Core 3.0:
+
+- [.NET Core](./3.0.0.md)
+- [.NET Core NuGet Packages](./standalone-packages/3.0.0-standalone-packages.md)

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages.md

@@ -0,0 +1,36 @@
+# API Difference standalone-2.2 vs standalone-3.0.
+
+API listing follows standard diff formatting. Lines preceded by a '+' are
+additions and a '-' indicates removal.
+
+* [System.ComponentModel.Composition](3.0.0-standalone-packages_System.ComponentModel.Composition.md)
+* [System.ComponentModel.Composition.Registration](3.0.0-standalone-packages_System.ComponentModel.Composition.Registration.md)
+* [System.Data.DataSetExtensions](3.0.0-standalone-packages_System.Data.DataSetExtensions.md)
+* [System.Data.OleDb](3.0.0-standalone-packages_System.Data.OleDb.md)
+* [System.Data.SqlClient](3.0.0-standalone-packages_System.Data.SqlClient.md)
+* [System.Diagnostics.DiagnosticSource](3.0.0-standalone-packages_System.Diagnostics.DiagnosticSource.md)
+* [System.Diagnostics.EventLog](3.0.0-standalone-packages_System.Diagnostics.EventLog.md)
+* [System.Diagnostics.PerformanceCounter](3.0.0-standalone-packages_System.Diagnostics.PerformanceCounter.md)
+* [System.DirectoryServices](3.0.0-standalone-packages_System.DirectoryServices.md)
+* [System.Drawing.Common](3.0.0-standalone-packages_System.Drawing.Common.md)
+* [System.IO.Packaging](3.0.0-standalone-packages_System.IO.Packaging.md)
+* [System.IO.Pipelines](3.0.0-standalone-packages_System.IO.Pipelines.md)
+* [System.Numerics.Tensors](3.0.0-standalone-packages_System.Numerics.Tensors.md)
+* [System.Reflection.Context](3.0.0-standalone-packages_System.Reflection.Context.md)
+* [System.Reflection.MetadataLoadContext](3.0.0-standalone-packages_System.Reflection.MetadataLoadContext.md)
+* [System.Resources.Extensions](3.0.0-standalone-packages_System.Resources.Extensions.md)
+* [System.Runtime.CompilerServices.Unsafe](3.0.0-standalone-packages_System.Runtime.CompilerServices.Unsafe.md)
+* [System.Runtime.Intrinsics.Experimental](3.0.0-standalone-packages_System.Runtime.Intrinsics.Experimental.md)
+* [System.Runtime.WindowsRuntime](3.0.0-standalone-packages_System.Runtime.WindowsRuntime.md)
+* [System.Runtime.WindowsRuntime.UI.Xaml](3.0.0-standalone-packages_System.Runtime.WindowsRuntime.UI.Xaml.md)
+* [System.Security.AccessControl](3.0.0-standalone-packages_System.Security.AccessControl.md)
+* [System.Security.Cryptography.OpenSsl](3.0.0-standalone-packages_System.Security.Cryptography.OpenSsl.md)
+* [System.Security.Cryptography.Pkcs](3.0.0-standalone-packages_System.Security.Cryptography.Pkcs.md)
+* [System.Security.Cryptography.Xml](3.0.0-standalone-packages_System.Security.Cryptography.Xml.md)
+* [System.Security.Permissions](3.0.0-standalone-packages_System.Security.Permissions.md)
+* [System.Security.Principal.Windows](3.0.0-standalone-packages_System.Security.Principal.Windows.md)
+* [System.Text.Encoding.CodePages](3.0.0-standalone-packages_System.Text.Encoding.CodePages.md)
+* [System.Text.Encodings.Web](3.0.0-standalone-packages_System.Text.Encodings.Web.md)
+* [System.Threading.Channels](3.0.0-standalone-packages_System.Threading.Channels.md)
+* [System.Windows.Extensions](3.0.0-standalone-packages_System.Windows.Extensions.md)
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.ComponentModel.Composition.Registration.md

@@ -0,0 +1,78 @@
+# System.ComponentModel.Composition.Registration
+
+``` diff
+ {
++    namespace System.ComponentModel.Composition.Registration {
++        public sealed class ExportBuilder {
++            public ExportBuilder();
++            public ExportBuilder AddMetadata(string name, Func<Type, object> itemFunc);
++            public ExportBuilder AddMetadata(string name, object value);
++            public ExportBuilder AsContractName(string contractName);
++            public ExportBuilder AsContractType(Type type);
++            public ExportBuilder AsContractType<T>();
++            public ExportBuilder Inherited();
++        }
++        public sealed class ImportBuilder {
++            public ImportBuilder();
++            public ImportBuilder AllowDefault();
++            public ImportBuilder AllowRecomposition();
++            public ImportBuilder AsContractName(string contractName);
++            public ImportBuilder AsContractType(Type type);
++            public ImportBuilder AsContractType<T>();
++            public ImportBuilder AsMany(bool isMany = true);
++            public ImportBuilder RequiredCreationPolicy(CreationPolicy requiredCreationPolicy);
++            public ImportBuilder Source(ImportSource source);
++        }
++        public class ParameterImportBuilder {
++            public ParameterImportBuilder();
++            public T Import<T>();
++            public T Import<T>(Action<ImportBuilder> configure);
++        }
++        public class PartBuilder {
++            public PartBuilder AddMetadata(string name, Func<Type, object> itemFunc);
++            public PartBuilder AddMetadata(string name, object value);
++            public PartBuilder Export();
++            public PartBuilder Export(Action<ExportBuilder> exportConfiguration);
++            public PartBuilder Export<T>();
++            public PartBuilder Export<T>(Action<ExportBuilder> exportConfiguration);
++            public PartBuilder ExportInterfaces();
++            public PartBuilder ExportInterfaces(Predicate<Type> interfaceFilter);
++            public PartBuilder ExportInterfaces(Predicate<Type> interfaceFilter, Action<Type, ExportBuilder> exportConfiguration);
++            public PartBuilder ExportProperties(Predicate<PropertyInfo> propertyFilter);
++            public PartBuilder ExportProperties(Predicate<PropertyInfo> propertyFilter, Action<PropertyInfo, ExportBuilder> exportConfiguration);
++            public PartBuilder ExportProperties<T>(Predicate<PropertyInfo> propertyFilter);
++            public PartBuilder ExportProperties<T>(Predicate<PropertyInfo> propertyFilter, Action<PropertyInfo, ExportBuilder> exportConfiguration);
++            public PartBuilder ImportProperties(Predicate<PropertyInfo> propertyFilter);
++            public PartBuilder ImportProperties(Predicate<PropertyInfo> propertyFilter, Action<PropertyInfo, ImportBuilder> importConfiguration);
++            public PartBuilder ImportProperties<T>(Predicate<PropertyInfo> propertyFilter);
++            public PartBuilder ImportProperties<T>(Predicate<PropertyInfo> propertyFilter, Action<PropertyInfo, ImportBuilder> importConfiguration);
++            public PartBuilder SelectConstructor(Func<ConstructorInfo[], ConstructorInfo> constructorFilter);
++            public PartBuilder SelectConstructor(Func<ConstructorInfo[], ConstructorInfo> constructorFilter, Action<ParameterInfo, ImportBuilder> importConfiguration);
++            public PartBuilder SetCreationPolicy(CreationPolicy creationPolicy);
++        }
++        public class PartBuilder<T> : PartBuilder {
++            public PartBuilder<T> ExportProperty(Expression<Func<T, object>> propertyFilter);
++            public PartBuilder<T> ExportProperty(Expression<Func<T, object>> propertyFilter, Action<ExportBuilder> exportConfiguration);
++            public PartBuilder<T> ExportProperty<TContract>(Expression<Func<T, object>> propertyFilter);
++            public PartBuilder<T> ExportProperty<TContract>(Expression<Func<T, object>> propertyFilter, Action<ExportBuilder> exportConfiguration);
++            public PartBuilder<T> ImportProperty(Expression<Func<T, object>> propertyFilter);
++            public PartBuilder<T> ImportProperty(Expression<Func<T, object>> propertyFilter, Action<ImportBuilder> importConfiguration);
++            public PartBuilder<T> ImportProperty<TContract>(Expression<Func<T, object>> propertyFilter);
++            public PartBuilder<T> ImportProperty<TContract>(Expression<Func<T, object>> propertyFilter, Action<ImportBuilder> importConfiguration);
++            public PartBuilder<T> SelectConstructor(Expression<Func<ParameterImportBuilder, T>> constructorFilter);
++        }
++        public class RegistrationBuilder : CustomReflectionContext {
++            public RegistrationBuilder();
++            public PartBuilder ForType(Type type);
++            public PartBuilder<T> ForType<T>();
++            public PartBuilder ForTypesDerivedFrom(Type type);
++            public PartBuilder<T> ForTypesDerivedFrom<T>();
++            public PartBuilder ForTypesMatching(Predicate<Type> typeFilter);
++            public PartBuilder<T> ForTypesMatching<T>(Predicate<Type> typeFilter);
++            protected override IEnumerable<object> GetCustomAttributes(MemberInfo member, IEnumerable<object> declaredAttributes);
++            protected override IEnumerable<object> GetCustomAttributes(ParameterInfo parameter, IEnumerable<object> declaredAttributes);
++        }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.ComponentModel.Composition.md

@@ -0,0 +1,13 @@
+# System.ComponentModel.Composition
+
+``` diff
+ {
+     namespace System.ComponentModel.Composition.Primitives {
+         public class ComposablePartException : Exception {
++            protected ComposablePartException(SerializationInfo info, StreamingContext context);
++            public override void GetObjectData(SerializationInfo info, StreamingContext context);
+         }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Data.DataSetExtensions.md

@@ -0,0 +1,128 @@
+# System.Data.DataSetExtensions
+
+``` diff
+ {
+ {
+-    namespace System.Data {
+ {
+-        public static class DataRowComparer {
+ {
+-            public static DataRowComparer<DataRow> Default { get; }
+
+-        }
+-        public sealed class DataRowComparer<TRow> : IEqualityComparer<TRow> where TRow : DataRow {
+ {
+-            public static DataRowComparer<TRow> Default { get; }
+
+-            public bool Equals(TRow leftRow, TRow rightRow);
+
+-            public int GetHashCode(TRow row);
+
+-        }
+-        public static class DataRowExtensions {
+ {
+-            public static T Field<T>(this DataRow row, DataColumn column);
+
+-            public static T Field<T>(this DataRow row, DataColumn column, DataRowVersion version);
+
+-            public static T Field<T>(this DataRow row, int columnIndex);
+
+-            public static T Field<T>(this DataRow row, int columnIndex, DataRowVersion version);
+
+-            public static T Field<T>(this DataRow row, string columnName);
+
+-            public static T Field<T>(this DataRow row, string columnName, DataRowVersion version);
+
+-            public static void SetField<T>(this DataRow row, DataColumn column, T value);
+
+-            public static void SetField<T>(this DataRow row, int columnIndex, T value);
+
+-            public static void SetField<T>(this DataRow row, string columnName, T value);
+
+-        }
+-        public static class DataTableExtensions {
+ {
+-            public static EnumerableRowCollection<DataRow> AsEnumerable(this DataTable source);
+
+-            public static DataTable CopyToDataTable<T>(this IEnumerable<T> source) where T : DataRow;
+
+-            public static void CopyToDataTable<T>(this IEnumerable<T> source, DataTable table, LoadOption options) where T : DataRow;
+
+-            public static void CopyToDataTable<T>(this IEnumerable<T> source, DataTable table, LoadOption options, FillErrorEventHandler errorHandler) where T : DataRow;
+
+-        }
+-        public abstract class EnumerableRowCollection : IEnumerable {
+ {
+-            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+
+-        }
+-        public class EnumerableRowCollection<TRow> : EnumerableRowCollection, IEnumerable, IEnumerable<TRow> {
+ {
+-            public IEnumerator<TRow> GetEnumerator();
+
+-            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+
+-        }
+-        public static class EnumerableRowCollectionExtensions {
+ {
+-            public static EnumerableRowCollection<TResult> Cast<TResult>(this EnumerableRowCollection source);
+
+-            public static OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this EnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector);
+
+-            public static OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this EnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer);
+
+-            public static OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this EnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector);
+
+-            public static OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this EnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer);
+
+-            public static EnumerableRowCollection<S> Select<TRow, S>(this EnumerableRowCollection<TRow> source, Func<TRow, S> selector);
+
+-            public static OrderedEnumerableRowCollection<TRow> ThenBy<TRow, TKey>(this OrderedEnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector);
+
+-            public static OrderedEnumerableRowCollection<TRow> ThenBy<TRow, TKey>(this OrderedEnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer);
+
+-            public static OrderedEnumerableRowCollection<TRow> ThenByDescending<TRow, TKey>(this OrderedEnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector);
+
+-            public static OrderedEnumerableRowCollection<TRow> ThenByDescending<TRow, TKey>(this OrderedEnumerableRowCollection<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer);
+
+-            public static EnumerableRowCollection<TRow> Where<TRow>(this EnumerableRowCollection<TRow> source, Func<TRow, bool> predicate);
+
+-        }
+-        public sealed class OrderedEnumerableRowCollection<TRow> : EnumerableRowCollection<TRow>
+
+-        public abstract class TypedTableBase<T> : DataTable, IEnumerable, IEnumerable<T> where T : DataRow {
+ {
+-            protected TypedTableBase();
+
+-            protected TypedTableBase(SerializationInfo info, StreamingContext context);
+
+-            public EnumerableRowCollection<TResult> Cast<TResult>();
+
+-            public IEnumerator<T> GetEnumerator();
+
+-            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+
+-        }
+-        public static class TypedTableBaseExtensions {
+ {
+-            public static EnumerableRowCollection<TRow> AsEnumerable<TRow>(this TypedTableBase<TRow> source) where TRow : DataRow;
+
+-            public static TRow ElementAtOrDefault<TRow>(this TypedTableBase<TRow> source, int index) where TRow : DataRow;
+
+-            public static OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this TypedTableBase<TRow> source, Func<TRow, TKey> keySelector) where TRow : DataRow;
+
+-            public static OrderedEnumerableRowCollection<TRow> OrderBy<TRow, TKey>(this TypedTableBase<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer) where TRow : DataRow;
+
+-            public static OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this TypedTableBase<TRow> source, Func<TRow, TKey> keySelector) where TRow : DataRow;
+
+-            public static OrderedEnumerableRowCollection<TRow> OrderByDescending<TRow, TKey>(this TypedTableBase<TRow> source, Func<TRow, TKey> keySelector, IComparer<TKey> comparer) where TRow : DataRow;
+
+-            public static EnumerableRowCollection<S> Select<TRow, S>(this TypedTableBase<TRow> source, Func<TRow, S> selector) where TRow : DataRow;
+
+-            public static EnumerableRowCollection<TRow> Where<TRow>(this TypedTableBase<TRow> source, Func<TRow, bool> predicate) where TRow : DataRow;
+
+-        }
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Data.OleDb.md

@@ -0,0 +1,425 @@
+# System.Data.OleDb
+
+``` diff
+ {
++    namespace System.Data.OleDb {
++        public sealed class OleDbCommand : DbCommand, ICloneable, IDbCommand, IDisposable {
++            public OleDbCommand();
++            public OleDbCommand(string cmdText);
++            public OleDbCommand(string cmdText, OleDbConnection connection);
++            public OleDbCommand(string cmdText, OleDbConnection connection, OleDbTransaction transaction);
++            public override string CommandText { get; set; }
++            public override int CommandTimeout { get; set; }
++            public override CommandType CommandType { get; set; }
++            public OleDbConnection Connection { get; set; }
++            protected override DbConnection DbConnection { get; set; }
++            protected override DbParameterCollection DbParameterCollection { get; }
++            protected override DbTransaction DbTransaction { get; set; }
++            public override bool DesignTimeVisible { get; set; }
++            public OleDbParameterCollection Parameters { get; }
++            public OleDbTransaction Transaction { get; set; }
++            public override UpdateRowSource UpdatedRowSource { get; set; }
++            public override void Cancel();
++            public OleDbCommand Clone();
++            protected override DbParameter CreateDbParameter();
++            public OleDbParameter CreateParameter();
++            protected override void Dispose(bool disposing);
++            protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior);
++            public override int ExecuteNonQuery();
++            public OleDbDataReader ExecuteReader();
++            public OleDbDataReader ExecuteReader(CommandBehavior behavior);
++            public override object ExecuteScalar();
++            public override void Prepare();
++            public void ResetCommandTimeout();
++            IDataReader System.Data.IDbCommand.ExecuteReader();
++            IDataReader System.Data.IDbCommand.ExecuteReader(CommandBehavior behavior);
++            object System.ICloneable.Clone();
++        }
++        public sealed class OleDbCommandBuilder : DbCommandBuilder {
++            public OleDbCommandBuilder();
++            public OleDbCommandBuilder(OleDbDataAdapter adapter);
++            public OleDbDataAdapter DataAdapter { get; set; }
++            protected override void ApplyParameterInfo(DbParameter parameter, DataRow datarow, StatementType statementType, bool whereClause);
++            public static void DeriveParameters(OleDbCommand command);
++            public OleDbCommand GetDeleteCommand();
++            public OleDbCommand GetDeleteCommand(bool useColumnsForParameterNames);
++            public OleDbCommand GetInsertCommand();
++            public OleDbCommand GetInsertCommand(bool useColumnsForParameterNames);
++            protected override string GetParameterName(int parameterOrdinal);
++            protected override string GetParameterName(string parameterName);
++            protected override string GetParameterPlaceholder(int parameterOrdinal);
++            public OleDbCommand GetUpdateCommand();
++            public OleDbCommand GetUpdateCommand(bool useColumnsForParameterNames);
++            public override string QuoteIdentifier(string unquotedIdentifier);
++            public string QuoteIdentifier(string unquotedIdentifier, OleDbConnection connection);
++            protected override void SetRowUpdatingHandler(DbDataAdapter adapter);
++            public override string UnquoteIdentifier(string quotedIdentifier);
++            public string UnquoteIdentifier(string quotedIdentifier, OleDbConnection connection);
++        }
++        public sealed class OleDbConnection : DbConnection, ICloneable, IDbConnection, IDisposable {
++            public OleDbConnection();
++            public OleDbConnection(string connectionString);
++            public override string ConnectionString { get; set; }
++            public override int ConnectionTimeout { get; }
++            public override string Database { get; }
++            public override string DataSource { get; }
++            public string Provider { get; }
++            public override string ServerVersion { get; }
++            public override ConnectionState State { get; }
++            public event OleDbInfoMessageEventHandler InfoMessage;
++            protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel);
++            public OleDbTransaction BeginTransaction();
++            public OleDbTransaction BeginTransaction(IsolationLevel isolationLevel);
++            public override void ChangeDatabase(string value);
++            public override void Close();
++            public OleDbCommand CreateCommand();
++            protected override DbCommand CreateDbCommand();
++            protected override void Dispose(bool disposing);
++            public override void EnlistTransaction(Transaction transaction);
++            public DataTable GetOleDbSchemaTable(Guid schema, object[] restrictions);
++            public override DataTable GetSchema();
++            public override DataTable GetSchema(string collectionName);
++            public override DataTable GetSchema(string collectionName, string[] restrictionValues);
++            public override void Open();
++            public static void ReleaseObjectPool();
++            public void ResetState();
++            object System.ICloneable.Clone();
++        }
++        public sealed class OleDbConnectionStringBuilder : DbConnectionStringBuilder {
++            public OleDbConnectionStringBuilder();
++            public OleDbConnectionStringBuilder(string connectionString);
++            public string DataSource { get; set; }
++            public string FileName { get; set; }
++            public override ICollection Keys { get; }
++            public int OleDbServices { get; set; }
++            public bool PersistSecurityInfo { get; set; }
++            public string Provider { get; set; }
++            public override object this[string keyword] { get; set; }
++            public override void Clear();
++            public override bool ContainsKey(string keyword);
++            public override bool Remove(string keyword);
++            public override bool TryGetValue(string keyword, out object value);
++        }
++        public sealed class OleDbDataAdapter : DbDataAdapter, ICloneable, IDataAdapter, IDbDataAdapter {
++            public OleDbDataAdapter();
++            public OleDbDataAdapter(OleDbCommand selectCommand);
++            public OleDbDataAdapter(string selectCommandText, OleDbConnection selectConnection);
++            public OleDbDataAdapter(string selectCommandText, string selectConnectionString);
++            public OleDbCommand DeleteCommand { get; set; }
++            public OleDbCommand InsertCommand { get; set; }
++            public OleDbCommand SelectCommand { get; set; }
++            IDbCommand System.Data.IDbDataAdapter.DeleteCommand { get; set; }
++            IDbCommand System.Data.IDbDataAdapter.InsertCommand { get; set; }
++            IDbCommand System.Data.IDbDataAdapter.SelectCommand { get; set; }
++            IDbCommand System.Data.IDbDataAdapter.UpdateCommand { get; set; }
++            public OleDbCommand UpdateCommand { get; set; }
++            public event OleDbRowUpdatedEventHandler RowUpdated;
++            public event OleDbRowUpdatingEventHandler RowUpdating;
++            protected override RowUpdatedEventArgs CreateRowUpdatedEvent(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping);
++            protected override RowUpdatingEventArgs CreateRowUpdatingEvent(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping);
++            public int Fill(DataSet dataSet, object ADODBRecordSet, string srcTable);
++            public int Fill(DataTable dataTable, object ADODBRecordSet);
++            protected override void OnRowUpdated(RowUpdatedEventArgs value);
++            protected override void OnRowUpdating(RowUpdatingEventArgs value);
++            object System.ICloneable.Clone();
++        }
++        public sealed class OleDbDataReader : DbDataReader {
++            public override int Depth { get; }
++            public override int FieldCount { get; }
++            public override bool HasRows { get; }
++            public override bool IsClosed { get; }
++            public override int RecordsAffected { get; }
++            public override object this[int index] { get; }
++            public override object this[string name] { get; }
++            public override int VisibleFieldCount { get; }
++            public override void Close();
++            public override bool GetBoolean(int ordinal);
++            public override byte GetByte(int ordinal);
++            public override long GetBytes(int ordinal, long dataIndex, byte[] buffer, int bufferIndex, int length);
++            public override char GetChar(int ordinal);
++            public override long GetChars(int ordinal, long dataIndex, char[] buffer, int bufferIndex, int length);
++            public OleDbDataReader GetData(int ordinal);
++            public override string GetDataTypeName(int index);
++            public override DateTime GetDateTime(int ordinal);
++            protected override DbDataReader GetDbDataReader(int ordinal);
++            public override Decimal GetDecimal(int ordinal);
++            public override double GetDouble(int ordinal);
++            public override IEnumerator GetEnumerator();
++            public override Type GetFieldType(int index);
++            public override float GetFloat(int ordinal);
++            public override Guid GetGuid(int ordinal);
++            public override short GetInt16(int ordinal);
++            public override int GetInt32(int ordinal);
++            public override long GetInt64(int ordinal);
++            public override string GetName(int index);
++            public override int GetOrdinal(string name);
++            public override DataTable GetSchemaTable();
++            public override string GetString(int ordinal);
++            public TimeSpan GetTimeSpan(int ordinal);
++            public override object GetValue(int ordinal);
++            public override int GetValues(object[] values);
++            public override bool IsDBNull(int ordinal);
++            public override bool NextResult();
++            public override bool Read();
++        }
++        public sealed class OleDbEnumerator {
++            public OleDbEnumerator();
++            public DataTable GetElements();
++            public static OleDbDataReader GetEnumerator(Type type);
++            public static OleDbDataReader GetRootEnumerator();
++        }
++        public sealed class OleDbError {
++            public string Message { get; }
++            public int NativeError { get; }
++            public string Source { get; }
++            public string SQLState { get; }
++            public override string ToString();
++        }
++        public sealed class OleDbErrorCollection : ICollection, IEnumerable {
++            public int Count { get; }
++            bool System.Collections.ICollection.IsSynchronized { get; }
++            object System.Collections.ICollection.SyncRoot { get; }
++            public OleDbError this[int index] { get; }
++            public void CopyTo(Array array, int index);
++            public void CopyTo(OleDbError[] array, int index);
++            public IEnumerator GetEnumerator();
++        }
++        public sealed class OleDbException : DbException {
++            public override int ErrorCode { get; }
++            public OleDbErrorCollection Errors { get; }
++            public override void GetObjectData(SerializationInfo si, StreamingContext context);
++        }
++        public sealed class OleDbFactory : DbProviderFactory {
++            public static readonly OleDbFactory Instance;
++            public override DbCommand CreateCommand();
++            public override DbCommandBuilder CreateCommandBuilder();
++            public override DbConnection CreateConnection();
++            public override DbConnectionStringBuilder CreateConnectionStringBuilder();
++            public override DbDataAdapter CreateDataAdapter();
++            public override DbParameter CreateParameter();
++        }
++        public sealed class OleDbInfoMessageEventArgs : EventArgs {
++            public int ErrorCode { get; }
++            public OleDbErrorCollection Errors { get; }
++            public string Message { get; }
++            public string Source { get; }
++            public override string ToString();
++        }
++        public delegate void OleDbInfoMessageEventHandler(object sender, OleDbInfoMessageEventArgs e);
++        public enum OleDbLiteral {
++            Binary_Literal = 1,
++            Catalog_Name = 2,
++            Catalog_Separator = 3,
++            Char_Literal = 4,
++            Column_Alias = 5,
++            Column_Name = 6,
++            Correlation_Name = 7,
++            Cube_Name = 21,
++            Cursor_Name = 8,
++            Dimension_Name = 22,
++            Escape_Percent_Prefix = 9,
++            Escape_Percent_Suffix = 29,
++            Escape_Underscore_Prefix = 10,
++            Escape_Underscore_Suffix = 30,
++            Hierarchy_Name = 23,
++            Index_Name = 11,
++            Invalid = 0,
++            Level_Name = 24,
++            Like_Percent = 12,
++            Like_Underscore = 13,
++            Member_Name = 25,
++            Procedure_Name = 14,
++            Property_Name = 26,
++            Quote_Prefix = 15,
++            Quote_Suffix = 28,
++            Schema_Name = 16,
++            Schema_Separator = 27,
++            Table_Name = 17,
++            Text_Command = 18,
++            User_Name = 19,
++            View_Name = 20,
++        }
++        public static class OleDbMetaDataCollectionNames {
++            public static readonly string Catalogs;
++            public static readonly string Collations;
++            public static readonly string Columns;
++            public static readonly string Indexes;
++            public static readonly string ProcedureColumns;
++            public static readonly string ProcedureParameters;
++            public static readonly string Procedures;
++            public static readonly string Tables;
++            public static readonly string Views;
++        }
++        public static class OleDbMetaDataColumnNames {
++            public static readonly string BooleanFalseLiteral;
++            public static readonly string BooleanTrueLiteral;
++            public static readonly string DateTimeDigits;
++            public static readonly string NativeDataType;
++        }
++        public sealed class OleDbParameter : DbParameter, ICloneable, IDataParameter, IDbDataParameter {
++            public OleDbParameter();
++            public OleDbParameter(string name, OleDbType dataType);
++            public OleDbParameter(string name, OleDbType dataType, int size);
++            public OleDbParameter(string parameterName, OleDbType dbType, int size, ParameterDirection direction, bool isNullable, byte precision, byte scale, string srcColumn, DataRowVersion srcVersion, object value);
++            public OleDbParameter(string parameterName, OleDbType dbType, int size, ParameterDirection direction, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion, bool sourceColumnNullMapping, object value);
++            public OleDbParameter(string name, OleDbType dataType, int size, string srcColumn);
++            public OleDbParameter(string name, object value);
++            public override DbType DbType { get; set; }
++            public override ParameterDirection Direction { get; set; }
++            public override bool IsNullable { get; set; }
++            public OleDbType OleDbType { get; set; }
++            public override string ParameterName { get; set; }
++            public byte Precision { get; set; }
++            public byte Scale { get; set; }
++            public override int Size { get; set; }
++            public override string SourceColumn { get; set; }
++            public override bool SourceColumnNullMapping { get; set; }
++            public override DataRowVersion SourceVersion { get; set; }
++            public override object Value { get; set; }
++            public override void ResetDbType();
++            public void ResetOleDbType();
++            object System.ICloneable.Clone();
++            public override string ToString();
++        }
++        public sealed class OleDbParameterCollection : DbParameterCollection {
++            public override int Count { get; }
++            public override bool IsFixedSize { get; }
++            public override bool IsReadOnly { get; }
++            public override bool IsSynchronized { get; }
++            public override object SyncRoot { get; }
++            public OleDbParameter this[int index] { get; set; }
++            public OleDbParameter this[string parameterName] { get; set; }
++            public OleDbParameter Add(OleDbParameter value);
++            public override int Add(object value);
++            public OleDbParameter Add(string parameterName, OleDbType oleDbType);
++            public OleDbParameter Add(string parameterName, OleDbType oleDbType, int size);
++            public OleDbParameter Add(string parameterName, OleDbType oleDbType, int size, string sourceColumn);
++            public OleDbParameter Add(string parameterName, object value);
++            public override void AddRange(Array values);
++            public void AddRange(OleDbParameter[] values);
++            public OleDbParameter AddWithValue(string parameterName, object value);
++            public override void Clear();
++            public bool Contains(OleDbParameter value);
++            public override bool Contains(object value);
++            public override bool Contains(string value);
++            public override void CopyTo(Array array, int index);
++            public void CopyTo(OleDbParameter[] array, int index);
++            public override IEnumerator GetEnumerator();
++            protected override DbParameter GetParameter(int index);
++            protected override DbParameter GetParameter(string parameterName);
++            public int IndexOf(OleDbParameter value);
++            public override int IndexOf(object value);
++            public override int IndexOf(string parameterName);
++            public void Insert(int index, OleDbParameter value);
++            public override void Insert(int index, object value);
++            public void Remove(OleDbParameter value);
++            public override void Remove(object value);
++            public override void RemoveAt(int index);
++            public override void RemoveAt(string parameterName);
++            protected override void SetParameter(int index, DbParameter value);
++            protected override void SetParameter(string parameterName, DbParameter value);
++        }
++        public sealed class OleDbRowUpdatedEventArgs : RowUpdatedEventArgs {
++            public OleDbRowUpdatedEventArgs(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping);
++            public OleDbCommand Command { get; }
++        }
++        public delegate void OleDbRowUpdatedEventHandler(object sender, OleDbRowUpdatedEventArgs e);
++        public sealed class OleDbRowUpdatingEventArgs : RowUpdatingEventArgs {
++            public OleDbRowUpdatingEventArgs(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping);
++            protected override IDbCommand BaseCommand { get; set; }
++            public OleDbCommand Command { get; set; }
++        }
++        public delegate void OleDbRowUpdatingEventHandler(object sender, OleDbRowUpdatingEventArgs e);
++        public sealed class OleDbSchemaGuid {
++            public static readonly Guid Assertions;
++            public static readonly Guid Catalogs;
++            public static readonly Guid Character_Sets;
++            public static readonly Guid Check_Constraints;
++            public static readonly Guid Check_Constraints_By_Table;
++            public static readonly Guid Collations;
++            public static readonly Guid Columns;
++            public static readonly Guid Column_Domain_Usage;
++            public static readonly Guid Column_Privileges;
++            public static readonly Guid Constraint_Column_Usage;
++            public static readonly Guid Constraint_Table_Usage;
++            public static readonly Guid DbInfoKeywords;
++            public static readonly Guid DbInfoLiterals;
++            public static readonly Guid Foreign_Keys;
++            public static readonly Guid Indexes;
++            public static readonly Guid Key_Column_Usage;
++            public static readonly Guid Primary_Keys;
++            public static readonly Guid Procedures;
++            public static readonly Guid Procedure_Columns;
++            public static readonly Guid Procedure_Parameters;
++            public static readonly Guid Provider_Types;
++            public static readonly Guid Referential_Constraints;
++            public static readonly Guid SchemaGuids;
++            public static readonly Guid Schemata;
++            public static readonly Guid Sql_Languages;
++            public static readonly Guid Statistics;
++            public static readonly Guid Tables;
++            public static readonly Guid Tables_Info;
++            public static readonly Guid Table_Constraints;
++            public static readonly Guid Table_Privileges;
++            public static readonly Guid Table_Statistics;
++            public static readonly Guid Translations;
++            public static readonly Guid Trustee;
++            public static readonly Guid Usage_Privileges;
++            public static readonly Guid Views;
++            public static readonly Guid View_Column_Usage;
++            public static readonly Guid View_Table_Usage;
++            public OleDbSchemaGuid();
++        }
++        public sealed class OleDbTransaction : DbTransaction {
++            public OleDbConnection Connection { get; }
++            protected override DbConnection DbConnection { get; }
++            public override IsolationLevel IsolationLevel { get; }
++            public OleDbTransaction Begin();
++            public OleDbTransaction Begin(IsolationLevel isolevel);
++            public override void Commit();
++            protected override void Dispose(bool disposing);
++            public override void Rollback();
++        }
++        public enum OleDbType {
++            BigInt = 20,
++            Binary = 128,
++            Boolean = 11,
++            BSTR = 8,
++            Char = 129,
++            Currency = 6,
++            Date = 7,
++            DBDate = 133,
++            DBTime = 134,
++            DBTimeStamp = 135,
++            Decimal = 14,
++            Double = 5,
++            Empty = 0,
++            Error = 10,
++            Filetime = 64,
++            Guid = 72,
++            IDispatch = 9,
++            Integer = 3,
++            IUnknown = 13,
++            LongVarBinary = 205,
++            LongVarChar = 201,
++            LongVarWChar = 203,
++            Numeric = 131,
++            PropVariant = 138,
++            Single = 4,
++            SmallInt = 2,
++            TinyInt = 16,
++            UnsignedBigInt = 21,
++            UnsignedInt = 19,
++            UnsignedSmallInt = 18,
++            UnsignedTinyInt = 17,
++            VarBinary = 204,
++            VarChar = 200,
++            Variant = 12,
++            VarNumeric = 139,
++            VarWChar = 202,
++            WChar = 130,
++        }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Data.SqlClient.md

@@ -0,0 +1,55 @@
+# System.Data.SqlClient
+
+``` diff
+ {
+     namespace Microsoft.SqlServer.Server {
++        public class SqlFacetAttribute : Attribute {
++            public SqlFacetAttribute();
++            public bool IsFixedLength { get; set; }
++            public bool IsNullable { get; set; }
++            public int MaxSize { get; set; }
++            public int Precision { get; set; }
++            public int Scale { get; set; }
++        }
+     }
+     namespace System.Data.SqlClient {
++        public enum PoolBlockingPeriod {
++            AlwaysBlock = 1,
++            Auto = 0,
++            NeverBlock = 2,
++        }
+         public sealed class SqlCommand : DbCommand, ICloneable {
++            public IAsyncResult BeginExecuteReader();
++            public IAsyncResult BeginExecuteReader(AsyncCallback callback, object stateObject);
++            public IAsyncResult BeginExecuteReader(AsyncCallback callback, object stateObject, CommandBehavior behavior);
++            public IAsyncResult BeginExecuteReader(CommandBehavior behavior);
++            public SqlDataReader EndExecuteReader(IAsyncResult asyncResult);
+         }
+         public sealed class SqlConnection : DbConnection, ICloneable {
++            public string AccessToken { get; set; }
+         }
+         public sealed class SqlConnectionStringBuilder : DbConnectionStringBuilder {
++            public PoolBlockingPeriod PoolBlockingPeriod { get; set; }
+         }
+     }
++    namespace System.Data.SqlTypes {
++        public sealed class SqlFileStream : Stream {
++            public SqlFileStream(string path, byte[] transactionContext, FileAccess access);
++            public SqlFileStream(string path, byte[] transactionContext, FileAccess access, FileOptions options, long allocationSize);
++            public override bool CanRead { get; }
++            public override bool CanSeek { get; }
++            public override bool CanWrite { get; }
++            public override long Length { get; }
++            public string Name { get; }
++            public override long Position { get; set; }
++            public byte[] TransactionContext { get; }
++            public override void Flush();
++            public override int Read(byte[] buffer, int offset, int count);
++            public override long Seek(long offset, SeekOrigin origin);
++            public override void SetLength(long value);
++            public override void Write(byte[] buffer, int offset, int count);
++        }
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Diagnostics.DiagnosticSource.md

@@ -0,0 +1,94 @@
+# System.Diagnostics.DiagnosticSource
+
+``` diff
+ {
+ {
+-    namespace System.Diagnostics {
+ {
+-        public class Activity {
+ {
+-            public Activity(string operationName);
+
+-            public IEnumerable<KeyValuePair<string, string>> Baggage { get; }
+
+-            public static Activity Current { get; private set; }
+
+-            public TimeSpan Duration { get; private set; }
+
+-            public string Id { get; private set; }
+
+-            public string OperationName { get; }
+
+-            public Activity Parent { get; private set; }
+
+-            public string ParentId { get; private set; }
+
+-            public string RootId { get; }
+
+-            public DateTime StartTimeUtc { get; private set; }
+
+-            public IEnumerable<KeyValuePair<string, string>> Tags { get; }
+
+-            public Activity AddBaggage(string key, string value);
+
+-            public Activity AddTag(string key, string value);
+
+-            public string GetBaggageItem(string key);
+
+-            public Activity SetEndTime(DateTime endTimeUtc);
+
+-            public Activity SetParentId(string parentId);
+
+-            public Activity SetStartTime(DateTime startTimeUtc);
+
+-            public Activity Start();
+
+-            public void Stop();
+
+-        }
+-        public class DiagnosticListener : DiagnosticSource, IDisposable, IObservable<KeyValuePair<string, object>> {
+ {
+-            public DiagnosticListener(string name);
+
+-            public static IObservable<DiagnosticListener> AllListeners { get; }
+
+-            public string Name { get; private set; }
+
+-            public virtual void Dispose();
+
+-            public bool IsEnabled();
+
+-            public override bool IsEnabled(string name);
+
+-            public override bool IsEnabled(string name, object arg1, object arg2 = null);
+
+-            public virtual IDisposable Subscribe(IObserver<KeyValuePair<string, object>> observer);
+
+-            public virtual IDisposable Subscribe(IObserver<KeyValuePair<string, object>> observer, Func<string, object, object, bool> isEnabled);
+
+-            public virtual IDisposable Subscribe(IObserver<KeyValuePair<string, object>> observer, Predicate<string> isEnabled);
+
+-            public override string ToString();
+
+-            public override void Write(string name, object value);
+
+-        }
+-        public abstract class DiagnosticSource {
+ {
+-            protected DiagnosticSource();
+
+-            public abstract bool IsEnabled(string name);
+
+-            public virtual bool IsEnabled(string name, object arg1, object arg2 = null);
+
+-            public Activity StartActivity(Activity activity, object args);
+
+-            public void StopActivity(Activity activity, object args);
+
+-            public abstract void Write(string name, object value);
+
+-        }
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Diagnostics.EventLog.md

@@ -0,0 +1,345 @@
+# System.Diagnostics.EventLog
+
+``` diff
+ {
+     namespace System.Diagnostics {
++        public sealed class EventLogTraceListener : TraceListener {
++            public EventLogTraceListener();
++            public EventLogTraceListener(EventLog eventLog);
++            public EventLogTraceListener(string source);
++            public EventLog EventLog { get; set; }
++            public override string Name { get; set; }
++            public override void Close();
++            protected override void Dispose(bool disposing);
++            public override void TraceData(TraceEventCache eventCache, string source, TraceEventType severity, int id, object data);
++            public override void TraceData(TraceEventCache eventCache, string source, TraceEventType severity, int id, params object[] data);
++            public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType severity, int id, string message);
++            public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType severity, int id, string format, params object[] args);
++            public override void Write(string message);
++            public override void WriteLine(string message);
++        }
+     }
++    namespace System.Diagnostics.Eventing.Reader {
++        public class EventBookmark
++        public sealed class EventKeyword {
++            public string DisplayName { get; }
++            public string Name { get; }
++            public long Value { get; }
++        }
++        public sealed class EventLevel {
++            public string DisplayName { get; }
++            public string Name { get; }
++            public int Value { get; }
++        }
++        public class EventLogConfiguration : IDisposable {
++            public EventLogConfiguration(string logName);
++            public EventLogConfiguration(string logName, EventLogSession session);
++            public bool IsClassicLog { get; }
++            public bool IsEnabled { get; set; }
++            public string LogFilePath { get; set; }
++            public EventLogIsolation LogIsolation { get; }
++            public EventLogMode LogMode { get; set; }
++            public string LogName { get; }
++            public EventLogType LogType { get; }
++            public long MaximumSizeInBytes { get; set; }
++            public string OwningProviderName { get; }
++            public Nullable<int> ProviderBufferSize { get; }
++            public Nullable<Guid> ProviderControlGuid { get; }
++            public Nullable<long> ProviderKeywords { get; set; }
++            public Nullable<int> ProviderLatency { get; }
++            public Nullable<int> ProviderLevel { get; set; }
++            public Nullable<int> ProviderMaximumNumberOfBuffers { get; }
++            public Nullable<int> ProviderMinimumNumberOfBuffers { get; }
++            public IEnumerable<string> ProviderNames { get; }
++            public string SecurityDescriptor { get; set; }
++            public void Dispose();
++            protected virtual void Dispose(bool disposing);
++            public void SaveChanges();
++        }
++        public class EventLogException : Exception {
++            public EventLogException();
++            protected EventLogException(int errorCode);
++            protected EventLogException(SerializationInfo serializationInfo, StreamingContext streamingContext);
++            public EventLogException(string message);
++            public EventLogException(string message, Exception innerException);
++            public override string Message { get; }
++            public override void GetObjectData(SerializationInfo info, StreamingContext context);
++        }
++        public sealed class EventLogInformation {
++            public Nullable<int> Attributes { get; }
++            public Nullable<DateTime> CreationTime { get; }
++            public Nullable<long> FileSize { get; }
++            public Nullable<bool> IsLogFull { get; }
++            public Nullable<DateTime> LastAccessTime { get; }
++            public Nullable<DateTime> LastWriteTime { get; }
++            public Nullable<long> OldestRecordNumber { get; }
++            public Nullable<long> RecordCount { get; }
++        }
++        public class EventLogInvalidDataException : EventLogException {
++            public EventLogInvalidDataException();
++            protected EventLogInvalidDataException(SerializationInfo serializationInfo, StreamingContext streamingContext);
++            public EventLogInvalidDataException(string message);
++            public EventLogInvalidDataException(string message, Exception innerException);
++        }
++        public enum EventLogIsolation {
++            Application = 0,
++            Custom = 2,
++            System = 1,
++        }
++        public sealed class EventLogLink {
++            public string DisplayName { get; }
++            public bool IsImported { get; }
++            public string LogName { get; }
++        }
++        public enum EventLogMode {
++            AutoBackup = 1,
++            Circular = 0,
++            Retain = 2,
++        }
++        public class EventLogNotFoundException : EventLogException {
++            public EventLogNotFoundException();
++            protected EventLogNotFoundException(SerializationInfo serializationInfo, StreamingContext streamingContext);
++            public EventLogNotFoundException(string message);
++            public EventLogNotFoundException(string message, Exception innerException);
++        }
++        public class EventLogPropertySelector : IDisposable {
++            public EventLogPropertySelector(IEnumerable<string> propertyQueries);
++            public void Dispose();
++            protected virtual void Dispose(bool disposing);
++        }
++        public class EventLogProviderDisabledException : EventLogException {
++            public EventLogProviderDisabledException();
++            protected EventLogProviderDisabledException(SerializationInfo serializationInfo, StreamingContext streamingContext);
++            public EventLogProviderDisabledException(string message);
++            public EventLogProviderDisabledException(string message, Exception innerException);
++        }
++        public class EventLogQuery {
++            public EventLogQuery(string path, PathType pathType);
++            public EventLogQuery(string path, PathType pathType, string query);
++            public bool ReverseDirection { get; set; }
++            public EventLogSession Session { get; set; }
++            public bool TolerateQueryErrors { get; set; }
++        }
++        public class EventLogReader : IDisposable {
++            public EventLogReader(EventLogQuery eventQuery);
++            public EventLogReader(EventLogQuery eventQuery, EventBookmark bookmark);
++            public EventLogReader(string path);
++            public EventLogReader(string path, PathType pathType);
++            public int BatchSize { get; set; }
++            public IList<EventLogStatus> LogStatus { get; }
++            public void CancelReading();
++            public void Dispose();
++            protected virtual void Dispose(bool disposing);
++            public EventRecord ReadEvent();
++            public EventRecord ReadEvent(TimeSpan timeout);
++            public void Seek(EventBookmark bookmark);
++            public void Seek(EventBookmark bookmark, long offset);
++            public void Seek(SeekOrigin origin, long offset);
++        }
++        public class EventLogReadingException : EventLogException {
++            public EventLogReadingException();
++            protected EventLogReadingException(SerializationInfo serializationInfo, StreamingContext streamingContext);
++            public EventLogReadingException(string message);
++            public EventLogReadingException(string message, Exception innerException);
++        }
++        public class EventLogRecord : EventRecord {
++            public override Nullable<Guid> ActivityId { get; }
++            public override EventBookmark Bookmark { get; }
++            public string ContainerLog { get; }
++            public override int Id { get; }
++            public override Nullable<long> Keywords { get; }
++            public override IEnumerable<string> KeywordsDisplayNames { get; }
++            public override Nullable<byte> Level { get; }
++            public override string LevelDisplayName { get; }
++            public override string LogName { get; }
++            public override string MachineName { get; }
++            public IEnumerable<int> MatchedQueryIds { get; }
++            public override Nullable<short> Opcode { get; }
++            public override string OpcodeDisplayName { get; }
++            public override Nullable<int> ProcessId { get; }
++            public override IList<EventProperty> Properties { get; }
++            public override Nullable<Guid> ProviderId { get; }
++            public override string ProviderName { get; }
++            public override Nullable<int> Qualifiers { get; }
++            public override Nullable<long> RecordId { get; }
++            public override Nullable<Guid> RelatedActivityId { get; }
++            public override Nullable<int> Task { get; }
++            public override string TaskDisplayName { get; }
++            public override Nullable<int> ThreadId { get; }
++            public override Nullable<DateTime> TimeCreated { get; }
++            public override SecurityIdentifier UserId { get; }
++            public override Nullable<byte> Version { get; }
++            protected override void Dispose(bool disposing);
++            public override string FormatDescription();
++            public override string FormatDescription(IEnumerable<object> values);
++            public IList<object> GetPropertyValues(EventLogPropertySelector propertySelector);
++            public override string ToXml();
++        }
++        public class EventLogSession : IDisposable {
++            public EventLogSession();
++            public EventLogSession(string server);
++            public EventLogSession(string server, string domain, string user, SecureString password, SessionAuthentication logOnType);
++            public static EventLogSession GlobalSession { get; }
++            public void CancelCurrentOperations();
++            public void ClearLog(string logName);
++            public void ClearLog(string logName, string backupPath);
++            public void Dispose();
++            protected virtual void Dispose(bool disposing);
++            public void ExportLog(string path, PathType pathType, string query, string targetFilePath);
++            public void ExportLog(string path, PathType pathType, string query, string targetFilePath, bool tolerateQueryErrors);
++            public void ExportLogAndMessages(string path, PathType pathType, string query, string targetFilePath);
++            public void ExportLogAndMessages(string path, PathType pathType, string query, string targetFilePath, bool tolerateQueryErrors, CultureInfo targetCultureInfo);
++            public EventLogInformation GetLogInformation(string logName, PathType pathType);
++            public IEnumerable<string> GetLogNames();
++            public IEnumerable<string> GetProviderNames();
++        }
++        public sealed class EventLogStatus {
++            public string LogName { get; }
++            public int StatusCode { get; }
++        }
++        public enum EventLogType {
++            Administrative = 0,
++            Analytical = 2,
++            Debug = 3,
++            Operational = 1,
++        }
++        public class EventLogWatcher : IDisposable {
++            public EventLogWatcher(EventLogQuery eventQuery);
++            public EventLogWatcher(EventLogQuery eventQuery, EventBookmark bookmark);
++            public EventLogWatcher(EventLogQuery eventQuery, EventBookmark bookmark, bool readExistingEvents);
++            public EventLogWatcher(string path);
++            public bool Enabled { get; set; }
++            public event EventHandler<EventRecordWrittenEventArgs> EventRecordWritten;
++            public void Dispose();
++            protected virtual void Dispose(bool disposing);
++        }
++        public sealed class EventMetadata {
++            public string Description { get; }
++            public long Id { get; }
++            public IEnumerable<EventKeyword> Keywords { get; }
++            public EventLevel Level { get; }
++            public EventLogLink LogLink { get; }
++            public EventOpcode Opcode { get; }
++            public EventTask Task { get; }
++            public string Template { get; }
++            public byte Version { get; }
++        }
++        public sealed class EventOpcode {
++            public string DisplayName { get; }
++            public string Name { get; }
++            public int Value { get; }
++        }
++        public sealed class EventProperty {
++            public object Value { get; }
++        }
++        public abstract class EventRecord : IDisposable {
++            protected EventRecord();
++            public abstract Nullable<Guid> ActivityId { get; }
++            public abstract EventBookmark Bookmark { get; }
++            public abstract int Id { get; }
++            public abstract Nullable<long> Keywords { get; }
++            public abstract IEnumerable<string> KeywordsDisplayNames { get; }
++            public abstract Nullable<byte> Level { get; }
++            public abstract string LevelDisplayName { get; }
++            public abstract string LogName { get; }
++            public abstract string MachineName { get; }
++            public abstract Nullable<short> Opcode { get; }
++            public abstract string OpcodeDisplayName { get; }
++            public abstract Nullable<int> ProcessId { get; }
++            public abstract IList<EventProperty> Properties { get; }
++            public abstract Nullable<Guid> ProviderId { get; }
++            public abstract string ProviderName { get; }
++            public abstract Nullable<int> Qualifiers { get; }
++            public abstract Nullable<long> RecordId { get; }
++            public abstract Nullable<Guid> RelatedActivityId { get; }
++            public abstract Nullable<int> Task { get; }
++            public abstract string TaskDisplayName { get; }
++            public abstract Nullable<int> ThreadId { get; }
++            public abstract Nullable<DateTime> TimeCreated { get; }
++            public abstract SecurityIdentifier UserId { get; }
++            public abstract Nullable<byte> Version { get; }
++            public void Dispose();
++            protected virtual void Dispose(bool disposing);
++            public abstract string FormatDescription();
++            public abstract string FormatDescription(IEnumerable<object> values);
++            public abstract string ToXml();
++        }
++        public sealed class EventRecordWrittenEventArgs : EventArgs {
++            public Exception EventException { get; }
++            public EventRecord EventRecord { get; }
++        }
++        public sealed class EventTask {
++            public string DisplayName { get; }
++            public Guid EventGuid { get; }
++            public string Name { get; }
++            public int Value { get; }
++        }
++        public enum PathType {
++            FilePath = 2,
++            LogName = 1,
++        }
++        public class ProviderMetadata : IDisposable {
++            public ProviderMetadata(string providerName);
++            public ProviderMetadata(string providerName, EventLogSession session, CultureInfo targetCultureInfo);
++            public string DisplayName { get; }
++            public IEnumerable<EventMetadata> Events { get; }
++            public Uri HelpLink { get; }
++            public Guid Id { get; }
++            public IList<EventKeyword> Keywords { get; }
++            public IList<EventLevel> Levels { get; }
++            public IList<EventLogLink> LogLinks { get; }
++            public string MessageFilePath { get; }
++            public string Name { get; }
++            public IList<EventOpcode> Opcodes { get; }
++            public string ParameterFilePath { get; }
++            public string ResourceFilePath { get; }
++            public IList<EventTask> Tasks { get; }
++            public void Dispose();
++            protected virtual void Dispose(bool disposing);
++        }
++        public enum SessionAuthentication {
++            Default = 0,
++            Kerberos = 2,
++            Negotiate = 1,
++            Ntlm = 3,
++        }
++        public enum StandardEventKeywords : long {
++            AuditFailure = (long)4503599627370496,
++            AuditSuccess = (long)9007199254740992,
++            CorrelationHint = (long)4503599627370496,
++            CorrelationHint2 = (long)18014398509481984,
++            EventLogClassic = (long)36028797018963968,
++            None = (long)0,
++            ResponseTime = (long)281474976710656,
++            Sqm = (long)2251799813685248,
++            WdiContext = (long)562949953421312,
++            WdiDiagnostic = (long)1125899906842624,
++        }
++        public enum StandardEventLevel {
++            Critical = 1,
++            Error = 2,
++            Informational = 4,
++            LogAlways = 0,
++            Verbose = 5,
++            Warning = 3,
++        }
++        public enum StandardEventOpcode {
++            DataCollectionStart = 3,
++            DataCollectionStop = 4,
++            Extension = 5,
++            Info = 0,
++            Receive = 240,
++            Reply = 6,
++            Resume = 7,
++            Send = 9,
++            Start = 1,
++            Stop = 2,
++            Suspend = 8,
++        }
++        public enum StandardEventTask {
++            None = 0,
++        }
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Diagnostics.PerformanceCounter.md

@@ -0,0 +1,82 @@
+# System.Diagnostics.PerformanceCounter
+
+``` diff
+ {
++    namespace System.Diagnostics.PerformanceData {
++        public sealed class CounterData {
++            public long RawValue { get; set; }
++            public long Value { get; set; }
++            public void Decrement();
++            public void Increment();
++            public void IncrementBy(long value);
++        }
++        public class CounterSet : IDisposable {
++            public CounterSet(Guid providerGuid, Guid counterSetGuid, CounterSetInstanceType instanceType);
++            public void AddCounter(int counterId, CounterType counterType);
++            public void AddCounter(int counterId, CounterType counterType, string counterName);
++            public CounterSetInstance CreateCounterSetInstance(string instanceName);
++            public void Dispose();
++            protected virtual void Dispose(bool disposing);
++            ~CounterSet();
++        }
++        public sealed class CounterSetInstance : IDisposable {
++            public CounterSetInstanceCounterDataSet Counters { get; }
++            public void Dispose();
++            ~CounterSetInstance();
++        }
++        public sealed class CounterSetInstanceCounterDataSet : IDisposable {
++            public CounterData this[int counterId] { get; }
++            public CounterData this[string counterName] { get; }
++            public void Dispose();
++            ~CounterSetInstanceCounterDataSet();
++        }
++        public enum CounterSetInstanceType {
++            GlobalAggregate = 4,
++            GlobalAggregateWithHistory = 11,
++            InstanceAggregate = 22,
++            Multiple = 2,
++            MultipleAggregate = 6,
++            Single = 0,
++        }
++        public enum CounterType {
++            AverageBase = 1073939458,
++            AverageCount64 = 1073874176,
++            AverageTimer32 = 805438464,
++            Delta32 = 4195328,
++            Delta64 = 4195584,
++            ElapsedTime = 807666944,
++            LargeQueueLength = 4523264,
++            MultiTimerBase = 1107494144,
++            MultiTimerPercentageActive = 574686464,
++            MultiTimerPercentageActive100Ns = 575735040,
++            MultiTimerPercentageNotActive = 591463680,
++            MultiTimerPercentageNotActive100Ns = 592512256,
++            ObjectSpecificTimer = 543229184,
++            PercentageActive = 541132032,
++            PercentageActive100Ns = 542180608,
++            PercentageNotActive = 557909248,
++            PercentageNotActive100Ns = 558957824,
++            PrecisionObjectSpecificTimer = 543622400,
++            PrecisionSystemTimer = 541525248,
++            PrecisionTimer100Ns = 542573824,
++            QueueLength = 4523008,
++            QueueLength100Ns = 5571840,
++            QueueLengthObjectTime = 6620416,
++            RateOfCountPerSecond32 = 272696320,
++            RateOfCountPerSecond64 = 272696576,
++            RawBase32 = 1073939459,
++            RawBase64 = 1073939712,
++            RawData32 = 65536,
++            RawData64 = 65792,
++            RawDataHex32 = 0,
++            RawDataHex64 = 256,
++            RawFraction32 = 537003008,
++            RawFraction64 = 537003264,
++            SampleBase = 1073939457,
++            SampleCounter = 4260864,
++            SampleFraction = 549585920,
++        }
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.DirectoryServices.md

@@ -0,0 +1,47 @@
+# System.DirectoryServices
+
+``` diff
+ {
+     namespace System.DirectoryServices {
++        public sealed class DirectoryServicesPermission : ResourcePermissionBase {
++            public DirectoryServicesPermission();
++            public DirectoryServicesPermission(DirectoryServicesPermissionAccess permissionAccess, string path);
++            public DirectoryServicesPermission(DirectoryServicesPermissionEntry[] permissionAccessEntries);
++            public DirectoryServicesPermission(PermissionState state);
++            public DirectoryServicesPermissionEntryCollection PermissionEntries { get; }
++        }
++        public enum DirectoryServicesPermissionAccess {
++            Browse = 2,
++            None = 0,
++            Write = 6,
++        }
++        public class DirectoryServicesPermissionAttribute : CodeAccessSecurityAttribute {
++            public DirectoryServicesPermissionAttribute(SecurityAction action);
++            public string Path { get; set; }
++            public DirectoryServicesPermissionAccess PermissionAccess { get; set; }
++            public override IPermission CreatePermission();
++        }
++        public class DirectoryServicesPermissionEntry {
++            public DirectoryServicesPermissionEntry(DirectoryServicesPermissionAccess permissionAccess, string path);
++            public string Path { get; }
++            public DirectoryServicesPermissionAccess PermissionAccess { get; }
++        }
++        public class DirectoryServicesPermissionEntryCollection : CollectionBase {
++            public DirectoryServicesPermissionEntry this[int index] { get; set; }
++            public int Add(DirectoryServicesPermissionEntry value);
++            public void AddRange(DirectoryServicesPermissionEntryCollection value);
++            public void AddRange(DirectoryServicesPermissionEntry[] value);
++            public bool Contains(DirectoryServicesPermissionEntry value);
++            public void CopyTo(DirectoryServicesPermissionEntry[] array, int index);
++            public int IndexOf(DirectoryServicesPermissionEntry value);
++            public void Insert(int index, DirectoryServicesPermissionEntry value);
++            protected override void OnClear();
++            protected override void OnInsert(int index, object value);
++            protected override void OnRemove(int index, object value);
++            protected override void OnSet(int index, object oldValue, object newValue);
++            public void Remove(DirectoryServicesPermissionEntry value);
++        }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Drawing.Common.md

@@ -0,0 +1,93 @@
+# System.Drawing.Common
+
+``` diff
+ {
+     namespace System.Drawing {
+-        public static class ColorTranslator {
+ {
+-            public static Color FromHtml(string htmlColor);
+
+-            public static Color FromOle(int oleColor);
+
+-            public static Color FromWin32(int win32Color);
+
+-            public static string ToHtml(Color c);
+
+-            public static int ToOle(Color c);
+
+-            public static int ToWin32(Color c);
+
+-        }
+-        public static class SystemColors {
+ {
+-            public static Color ActiveBorder { get; }
+
+-            public static Color ActiveCaption { get; }
+
+-            public static Color ActiveCaptionText { get; }
+
+-            public static Color AppWorkspace { get; }
+
+-            public static Color ButtonFace { get; }
+
+-            public static Color ButtonHighlight { get; }
+
+-            public static Color ButtonShadow { get; }
+
+-            public static Color Control { get; }
+
+-            public static Color ControlDark { get; }
+
+-            public static Color ControlDarkDark { get; }
+
+-            public static Color ControlLight { get; }
+
+-            public static Color ControlLightLight { get; }
+
+-            public static Color ControlText { get; }
+
+-            public static Color Desktop { get; }
+
+-            public static Color GradientActiveCaption { get; }
+
+-            public static Color GradientInactiveCaption { get; }
+
+-            public static Color GrayText { get; }
+
+-            public static Color Highlight { get; }
+
+-            public static Color HighlightText { get; }
+
+-            public static Color HotTrack { get; }
+
+-            public static Color InactiveBorder { get; }
+
+-            public static Color InactiveCaption { get; }
+
+-            public static Color InactiveCaptionText { get; }
+
+-            public static Color Info { get; }
+
+-            public static Color InfoText { get; }
+
+-            public static Color Menu { get; }
+
+-            public static Color MenuBar { get; }
+
+-            public static Color MenuHighlight { get; }
+
+-            public static Color MenuText { get; }
+
+-            public static Color ScrollBar { get; }
+
+-            public static Color Window { get; }
+
+-            public static Color WindowFrame { get; }
+
+-            public static Color WindowText { get; }
+
+-        }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.IO.Packaging.md

@@ -0,0 +1,17 @@
+# System.IO.Packaging
+
+``` diff
+ {
+     namespace System.IO.Packaging {
+         public static class PackUriHelper {
++            public static int ComparePackUri(Uri firstPackUri, Uri secondPackUri);
++            public static Uri Create(Uri packageUri);
++            public static Uri Create(Uri packageUri, Uri partUri);
++            public static Uri Create(Uri packageUri, Uri partUri, string fragment);
++            public static Uri GetPackageUri(Uri packUri);
++            public static Uri GetPartUri(Uri packUri);
+         }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.IO.Pipelines.md

@@ -0,0 +1,48 @@
+# System.IO.Pipelines
+
+``` diff
+ {
+     namespace System.IO.Pipelines {
+         public class PipeOptions {
+-            public PipeOptions(MemoryPool<byte> pool = null, PipeScheduler readerScheduler = null, PipeScheduler writerScheduler = null, long pauseWriterThreshold = (long)32768, long resumeWriterThreshold = (long)16384, int minimumSegmentSize = 2048, bool useSynchronizationContext = true);
++            public PipeOptions(MemoryPool<byte> pool = null, PipeScheduler readerScheduler = null, PipeScheduler writerScheduler = null, long pauseWriterThreshold = (long)-1, long resumeWriterThreshold = (long)-1, int minimumSegmentSize = -1, bool useSynchronizationContext = true);
+         }
+         public abstract class PipeReader {
++            public virtual Stream AsStream(bool leaveOpen = false);
++            public virtual ValueTask CompleteAsync(Exception exception = null);
++            public virtual Task CopyToAsync(PipeWriter destination, CancellationToken cancellationToken = default(CancellationToken));
++            public virtual Task CopyToAsync(Stream destination, CancellationToken cancellationToken = default(CancellationToken));
++            public static PipeReader Create(Stream stream, StreamPipeReaderOptions readerOptions = null);
+-            public abstract void OnWriterCompleted(Action<Exception, object> callback, object state);
++            public virtual void OnWriterCompleted(Action<Exception, object> callback, object state);
+         }
+         public abstract class PipeWriter : IBufferWriter<byte> {
++            public virtual Stream AsStream(bool leaveOpen = false);
++            public virtual ValueTask CompleteAsync(Exception exception = null);
++            protected internal virtual Task CopyFromAsync(Stream source, CancellationToken cancellationToken = default(CancellationToken));
++            public static PipeWriter Create(Stream stream, StreamPipeWriterOptions writerOptions = null);
+-            public abstract void OnReaderCompleted(Action<Exception, object> callback, object state);
++            public virtual void OnReaderCompleted(Action<Exception, object> callback, object state);
+         }
+-        public struct ReadResult
++        public readonly struct ReadResult
++        public static class StreamPipeExtensions {
++            public static Task CopyToAsync(this Stream source, PipeWriter destination, CancellationToken cancellationToken = default(CancellationToken));
++        }
++        public class StreamPipeReaderOptions {
++            public StreamPipeReaderOptions(MemoryPool<byte> pool = null, int bufferSize = -1, int minimumReadSize = -1, bool leaveOpen = false);
++            public int BufferSize { get; }
++            public bool LeaveOpen { get; }
++            public int MinimumReadSize { get; }
++            public MemoryPool<byte> Pool { get; }
++        }
++        public class StreamPipeWriterOptions {
++            public StreamPipeWriterOptions(MemoryPool<byte> pool = null, int minimumBufferSize = -1, bool leaveOpen = false);
++            public bool LeaveOpen { get; }
++            public int MinimumBufferSize { get; }
++            public MemoryPool<byte> Pool { get; }
++        }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Numerics.Tensors.md

@@ -0,0 +1,141 @@
+# System.Numerics.Tensors
+
+``` diff
+ {
++    namespace System.Numerics.Tensors {
++        public static class ArrayTensorExtensions {
++            public static CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this Array array, bool reverseStride = false);
++            public static CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[,,] array, bool reverseStride = false);
++            public static CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[,] array, bool reverseStride = false);
++            public static CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[] array);
++            public static SparseTensor<T> ToSparseTensor<T>(this Array array, bool reverseStride = false);
++            public static SparseTensor<T> ToSparseTensor<T>(this T[,,] array, bool reverseStride = false);
++            public static SparseTensor<T> ToSparseTensor<T>(this T[,] array, bool reverseStride = false);
++            public static SparseTensor<T> ToSparseTensor<T>(this T[] array);
++            public static DenseTensor<T> ToTensor<T>(this Array array, bool reverseStride = false);
++            public static DenseTensor<T> ToTensor<T>(this T[,,] array, bool reverseStride = false);
++            public static DenseTensor<T> ToTensor<T>(this T[,] array, bool reverseStride = false);
++            public static DenseTensor<T> ToTensor<T>(this T[] array);
++        }
++        public class CompressedSparseTensor<T> : Tensor<T> {
++            public CompressedSparseTensor(Memory<T> values, Memory<int> compressedCounts, Memory<int> indices, int nonZeroCount, ReadOnlySpan<int> dimensions, bool reverseStride = false);
++            public CompressedSparseTensor(ReadOnlySpan<int> dimensions, bool reverseStride = false);
++            public CompressedSparseTensor(ReadOnlySpan<int> dimensions, int capacity, bool reverseStride = false);
++            public int Capacity { get; }
++            public Memory<int> CompressedCounts { get; }
++            public Memory<int> Indices { get; }
++            public int NonZeroCount { get; }
++            public override T this[ReadOnlySpan<int> indices] { get; set; }
++            public Memory<T> Values { get; }
++            public override Tensor<T> Clone();
++            public override Tensor<TResult> CloneEmpty<TResult>(ReadOnlySpan<int> dimensions);
++            public override T GetValue(int index);
++            public override Tensor<T> Reshape(ReadOnlySpan<int> dimensions);
++            public override void SetValue(int index, T value);
++            public override CompressedSparseTensor<T> ToCompressedSparseTensor();
++            public override DenseTensor<T> ToDenseTensor();
++            public override SparseTensor<T> ToSparseTensor();
++        }
++        public class DenseTensor<T> : Tensor<T> {
++            public DenseTensor(int length);
++            public DenseTensor(Memory<T> memory, ReadOnlySpan<int> dimensions, bool reverseStride = false);
++            public DenseTensor(ReadOnlySpan<int> dimensions, bool reverseStride = false);
++            public Memory<T> Buffer { get; }
++            public override Tensor<T> Clone();
++            public override Tensor<TResult> CloneEmpty<TResult>(ReadOnlySpan<int> dimensions);
++            protected override void CopyTo(T[] array, int arrayIndex);
++            public override T GetValue(int index);
++            protected override int IndexOf(T item);
++            public override Tensor<T> Reshape(ReadOnlySpan<int> dimensions);
++            public override void SetValue(int index, T value);
++        }
++        public class SparseTensor<T> : Tensor<T> {
++            public SparseTensor(ReadOnlySpan<int> dimensions, bool reverseStride = false, int capacity = 0);
++            public int NonZeroCount { get; }
++            public override Tensor<T> Clone();
++            public override Tensor<TResult> CloneEmpty<TResult>(ReadOnlySpan<int> dimensions);
++            public override T GetValue(int index);
++            public override Tensor<T> Reshape(ReadOnlySpan<int> dimensions);
++            public override void SetValue(int index, T value);
++            public override CompressedSparseTensor<T> ToCompressedSparseTensor();
++            public override DenseTensor<T> ToDenseTensor();
++            public override SparseTensor<T> ToSparseTensor();
++        }
++        public static class Tensor {
++            public static Tensor<T> CreateFromDiagonal<T>(Tensor<T> diagonal);
++            public static Tensor<T> CreateFromDiagonal<T>(Tensor<T> diagonal, int offset);
++            public static Tensor<T> CreateIdentity<T>(int size);
++            public static Tensor<T> CreateIdentity<T>(int size, bool columMajor);
++            public static Tensor<T> CreateIdentity<T>(int size, bool columMajor, T oneValue);
++        }
++        public abstract class Tensor<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable {
++            protected Tensor(Array fromArray, bool reverseStride);
++            protected Tensor(int length);
++            protected Tensor(ReadOnlySpan<int> dimensions, bool reverseStride);
++            public ReadOnlySpan<int> Dimensions { get; }
++            public bool IsFixedSize { get; }
++            public bool IsReadOnly { get; }
++            public bool IsReversedStride { get; }
++            public long Length { get; }
++            public int Rank { get; }
++            public ReadOnlySpan<int> Strides { get; }
++            int System.Collections.Generic.ICollection<T>.Count { get; }
++            T System.Collections.Generic.IList<T>.this[int index] { get; set; }
++            int System.Collections.Generic.IReadOnlyCollection<T>.Count { get; }
++            T System.Collections.Generic.IReadOnlyList<T>.this[int index] { get; }
++            int System.Collections.ICollection.Count { get; }
++            bool System.Collections.ICollection.IsSynchronized { get; }
++            object System.Collections.ICollection.SyncRoot { get; }
++            object System.Collections.IList.this[int index] { get; set; }
++            public virtual T this[params int[] indices] { get; set; }
++            public virtual T this[ReadOnlySpan<int> indices] { get; set; }
++            public abstract Tensor<T> Clone();
++            public virtual Tensor<T> CloneEmpty();
++            public virtual Tensor<T> CloneEmpty(ReadOnlySpan<int> dimensions);
++            public virtual Tensor<TResult> CloneEmpty<TResult>();
++            public abstract Tensor<TResult> CloneEmpty<TResult>(ReadOnlySpan<int> dimensions);
++            public static int Compare(Tensor<T> left, Tensor<T> right);
++            protected virtual bool Contains(T item);
++            protected virtual void CopyTo(T[] array, int arrayIndex);
++            public static bool Equals(Tensor<T> left, Tensor<T> right);
++            public virtual void Fill(T value);
++            public string GetArrayString(bool includeWhitespace = true);
++            public Tensor<T> GetDiagonal();
++            public Tensor<T> GetDiagonal(int offset);
++            public Tensor<T> GetTriangle();
++            public Tensor<T> GetTriangle(int offset);
++            public Tensor<T> GetUpperTriangle();
++            public Tensor<T> GetUpperTriangle(int offset);
++            public abstract T GetValue(int index);
++            protected virtual int IndexOf(T item);
++            public abstract Tensor<T> Reshape(ReadOnlySpan<int> dimensions);
++            public abstract void SetValue(int index, T value);
++            void System.Collections.Generic.ICollection<T>.Add(T item);
++            void System.Collections.Generic.ICollection<T>.Clear();
++            bool System.Collections.Generic.ICollection<T>.Contains(T item);
++            void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
++            bool System.Collections.Generic.ICollection<T>.Remove(T item);
++            IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
++            int System.Collections.Generic.IList<T>.IndexOf(T item);
++            void System.Collections.Generic.IList<T>.Insert(int index, T item);
++            void System.Collections.Generic.IList<T>.RemoveAt(int index);
++            void System.Collections.ICollection.CopyTo(Array array, int index);
++            IEnumerator System.Collections.IEnumerable.GetEnumerator();
++            int System.Collections.IList.Add(object value);
++            void System.Collections.IList.Clear();
++            bool System.Collections.IList.Contains(object value);
++            int System.Collections.IList.IndexOf(object value);
++            void System.Collections.IList.Insert(int index, object value);
++            void System.Collections.IList.Remove(object value);
++            void System.Collections.IList.RemoveAt(int index);
++            int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
++            bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
++            int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
++            public virtual CompressedSparseTensor<T> ToCompressedSparseTensor();
++            public virtual DenseTensor<T> ToDenseTensor();
++            public virtual SparseTensor<T> ToSparseTensor();
++        }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Reflection.Context.md

@@ -0,0 +1,20 @@
+# System.Reflection.Context
+
+``` diff
+ {
++    namespace System.Reflection.Context {
++        public abstract class CustomReflectionContext : ReflectionContext {
++            protected CustomReflectionContext();
++            protected CustomReflectionContext(ReflectionContext source);
++            protected virtual IEnumerable<PropertyInfo> AddProperties(Type type);
++            protected PropertyInfo CreateProperty(Type propertyType, string name, Func<object, object> getter, Action<object, object> setter);
++            protected PropertyInfo CreateProperty(Type propertyType, string name, Func<object, object> getter, Action<object, object> setter, IEnumerable<Attribute> propertyCustomAttributes, IEnumerable<Attribute> getterCustomAttributes, IEnumerable<Attribute> setterCustomAttributes);
++            protected virtual IEnumerable<object> GetCustomAttributes(MemberInfo member, IEnumerable<object> declaredAttributes);
++            protected virtual IEnumerable<object> GetCustomAttributes(ParameterInfo parameter, IEnumerable<object> declaredAttributes);
++            public override Assembly MapAssembly(Assembly assembly);
++            public override TypeInfo MapType(TypeInfo type);
++        }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Reflection.MetadataLoadContext.md

@@ -0,0 +1,28 @@
+# System.Reflection.MetadataLoadContext
+
+``` diff
+ {
++    namespace System.Reflection {
++        public abstract class MetadataAssemblyResolver {
++            protected MetadataAssemblyResolver();
++            public abstract Assembly Resolve(MetadataLoadContext context, AssemblyName assemblyName);
++        }
++        public sealed class MetadataLoadContext : IDisposable {
++            public MetadataLoadContext(MetadataAssemblyResolver resolver, string coreAssemblyName = null);
++            public Assembly CoreAssembly { get; }
++            public void Dispose();
++            public IEnumerable<Assembly> GetAssemblies();
++            public Assembly LoadFromAssemblyName(AssemblyName assemblyName);
++            public Assembly LoadFromAssemblyName(string assemblyName);
++            public Assembly LoadFromAssemblyPath(string assemblyPath);
++            public Assembly LoadFromByteArray(byte[] assembly);
++            public Assembly LoadFromStream(Stream assembly);
++        }
++        public class PathAssemblyResolver : MetadataAssemblyResolver {
++            public PathAssemblyResolver(IEnumerable<string> assemblyPaths);
++            public override Assembly Resolve(MetadataLoadContext context, AssemblyName assemblyName);
++        }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Resources.Extensions.md

@@ -0,0 +1,32 @@
+# System.Resources.Extensions
+
+``` diff
+ {
++    namespace System.Resources.Extensions {
++        public sealed class DeserializingResourceReader : IDisposable, IEnumerable, IResourceReader {
++            public DeserializingResourceReader(Stream stream);
++            public DeserializingResourceReader(string fileName);
++            public void Close();
++            public void Dispose();
++            public IDictionaryEnumerator GetEnumerator();
++            IEnumerator System.Collections.IEnumerable.GetEnumerator();
++        }
++        public sealed class PreserializedResourceWriter : IDisposable, IResourceWriter {
++            public PreserializedResourceWriter(Stream stream);
++            public PreserializedResourceWriter(string fileName);
++            public void AddActivatorResource(string name, Stream value, string typeName, bool closeAfterWrite = false);
++            public void AddBinaryFormattedResource(string name, byte[] value, string typeName = null);
++            public void AddResource(string name, byte[] value);
++            public void AddResource(string name, Stream value, bool closeAfterWrite = false);
++            public void AddResource(string name, object value);
++            public void AddResource(string name, string value);
++            public void AddResource(string name, string value, string typeName);
++            public void AddTypeConverterResource(string name, byte[] value, string typeName);
++            public void Close();
++            public void Dispose();
++            public void Generate();
++        }
++    }
++}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Runtime.CompilerServices.Unsafe.md

@@ -0,0 +1,82 @@
+# System.Runtime.CompilerServices.Unsafe
+
+``` diff
+ {
+ {
+-    namespace System.Runtime.CompilerServices {
+ {
+-        public static class Unsafe {
+ {
+-            public unsafe static void* Add<T>(void* source, int elementOffset);
+
+-            public static ref T Add<T>(ref T source, int elementOffset);
+
+-            public static ref T Add<T>(ref T source, IntPtr elementOffset);
+
+-            public static ref T AddByteOffset<T>(ref T source, IntPtr byteOffset);
+
+-            public static bool AreSame<T>(ref T left, ref T right);
+
+-            public static T As<T>(object o) where T : class;
+
+-            public static ref TTo As<TFrom, TTo>(ref TFrom source);
+
+-            public unsafe static void* AsPointer<T>(ref T value);
+
+-            public unsafe static ref T AsRef<T>(void* source);
+
+-            public static ref T AsRef<T>(in T source);
+
+-            public static IntPtr ByteOffset<T>(ref T origin, ref T target);
+
+-            public unsafe static void Copy<T>(void* destination, ref T source);
+
+-            public unsafe static void Copy<T>(ref T destination, void* source);
+
+-            public static void CopyBlock(ref byte destination, ref byte source, uint byteCount);
+
+-            public unsafe static void CopyBlock(void* destination, void* source, uint byteCount);
+
+-            public static void CopyBlockUnaligned(ref byte destination, ref byte source, uint byteCount);
+
+-            public unsafe static void CopyBlockUnaligned(void* destination, void* source, uint byteCount);
+
+-            public static void InitBlock(ref byte startAddress, byte value, uint byteCount);
+
+-            public unsafe static void InitBlock(void* startAddress, byte value, uint byteCount);
+
+-            public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount);
+
+-            public unsafe static void InitBlockUnaligned(void* startAddress, byte value, uint byteCount);
+
+-            public static bool IsAddressGreaterThan<T>(ref T left, ref T right);
+
+-            public static bool IsAddressLessThan<T>(ref T left, ref T right);
+
+-            public unsafe static T Read<T>(void* source);
+
+-            public static T ReadUnaligned<T>(ref byte source);
+
+-            public unsafe static T ReadUnaligned<T>(void* source);
+
+-            public static int SizeOf<T>();
+
+-            public unsafe static void* Subtract<T>(void* source, int elementOffset);
+
+-            public static ref T Subtract<T>(ref T source, int elementOffset);
+
+-            public static ref T Subtract<T>(ref T source, IntPtr elementOffset);
+
+-            public static ref T SubtractByteOffset<T>(ref T source, IntPtr byteOffset);
+
+-            public unsafe static void Write<T>(void* destination, T value);
+
+-            public static void WriteUnaligned<T>(ref byte destination, T value);
+
+-            public unsafe static void WriteUnaligned<T>(void* destination, T value);
+
+-        }
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Runtime.WindowsRuntime.UI.Xaml.md

@@ -0,0 +1,17 @@
+# System.Runtime.WindowsRuntime.UI.Xaml
+
+``` diff
+ {
+     namespace Windows.UI.Xaml {
+         public class LayoutCycleException : Exception {
++            protected LayoutCycleException(SerializationInfo serializationInfo, StreamingContext streamingContext);
+         }
+     }
+     namespace Windows.UI.Xaml.Automation {
+         public class ElementNotAvailableException : Exception {
++            protected ElementNotAvailableException(SerializationInfo serializationInfo, StreamingContext streamingContext);
+         }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Runtime.WindowsRuntime.md

@@ -0,0 +1,14 @@
+# System.Runtime.WindowsRuntime
+
+``` diff
+ {
+     namespace System.IO {
+         public static class WindowsRuntimeStorageExtensions {
++            public static SafeFileHandle CreateSafeFileHandle(this IStorageFile windowsRuntimeFile, FileAccess access = 3, FileShare share = 1, FileOptions options = 0);
++            public static SafeFileHandle CreateSafeFileHandle(this IStorageFolder rootDirectory, string relativePath, FileMode mode);
++            public static SafeFileHandle CreateSafeFileHandle(this IStorageFolder rootDirectory, string relativePath, FileMode mode, FileAccess access, FileShare share = 1, FileOptions options = 0);
+         }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Security.AccessControl.md

@@ -0,0 +1,22 @@
+# System.Security.AccessControl
+
+``` diff
+ {
+     namespace System.Security.AccessControl {
+-        public class AccessRule<T> : AccessRule where T : struct, ValueType
++        public class AccessRule<T> : AccessRule where T : struct
+-        public class AuditRule<T> : AuditRule where T : struct, ValueType
++        public class AuditRule<T> : AuditRule where T : struct
+         public abstract class GenericSecurityDescriptor {
+-            protected GenericSecurityDescriptor();
+
+         }
+         public abstract class ObjectSecurity {
++            protected CommonSecurityDescriptor SecurityDescriptor { get; }
+         }
+-        public abstract class ObjectSecurity<T> : NativeObjectSecurity where T : struct, ValueType
++        public abstract class ObjectSecurity<T> : NativeObjectSecurity where T : struct
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Security.Cryptography.OpenSsl.md

@@ -0,0 +1,12 @@
+# System.Security.Cryptography.OpenSsl
+
+``` diff
+ {
+     namespace System.Security.Cryptography {
+         public sealed class SafeEvpPKeyHandle : SafeHandle {
++            public static long OpenSslVersion { get; }
+         }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Security.Cryptography.Pkcs.md

@@ -0,0 +1,166 @@
+# System.Security.Cryptography.Pkcs
+
+``` diff
+ {
+     namespace System.Security.Cryptography {
+         public sealed class CryptographicAttributeObjectCollection : ICollection, IEnumerable {
++            public bool IsSynchronized { get; }
++            public object SyncRoot { get; }
+-            bool System.Collections.ICollection.IsSynchronized { get; }
+
+-            object System.Collections.ICollection.SyncRoot { get; }
+
+         }
+     }
+     namespace System.Security.Cryptography.Pkcs {
+         public sealed class AlgorithmIdentifier {
++            public byte[] Parameters { get; set; }
+         }
+         public sealed class CmsRecipient {
++            public CmsRecipient(SubjectIdentifierType recipientIdentifierType, X509Certificate2 certificate, RSAEncryptionPadding rsaEncryptionPadding);
++            public CmsRecipient(X509Certificate2 certificate, RSAEncryptionPadding rsaEncryptionPadding);
++            public RSAEncryptionPadding RSAEncryptionPadding { get; }
+         }
+         public sealed class CmsRecipientCollection : ICollection, IEnumerable {
++            public bool IsSynchronized { get; }
++            public object SyncRoot { get; }
+-            bool System.Collections.ICollection.IsSynchronized { get; }
+
+-            object System.Collections.ICollection.SyncRoot { get; }
+
+         }
+         public sealed class CmsSigner {
++            public CmsSigner(SubjectIdentifierType signerIdentifierType, X509Certificate2 certificate, AsymmetricAlgorithm privateKey);
++            public AsymmetricAlgorithm PrivateKey { get; set; }
+         }
+         public sealed class EnvelopedCms {
++            public void Decrypt(RecipientInfo recipientInfo, AsymmetricAlgorithm privateKey);
+         }
++        public sealed class Pkcs12Builder {
++            public Pkcs12Builder();
++            public bool IsSealed { get; }
++            public void AddSafeContentsEncrypted(Pkcs12SafeContents safeContents, byte[] passwordBytes, PbeParameters pbeParameters);
++            public void AddSafeContentsEncrypted(Pkcs12SafeContents safeContents, ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters);
++            public void AddSafeContentsEncrypted(Pkcs12SafeContents safeContents, ReadOnlySpan<char> password, PbeParameters pbeParameters);
++            public void AddSafeContentsEncrypted(Pkcs12SafeContents safeContents, string password, PbeParameters pbeParameters);
++            public void AddSafeContentsUnencrypted(Pkcs12SafeContents safeContents);
++            public byte[] Encode();
++            public void SealWithMac(ReadOnlySpan<char> password, HashAlgorithmName hashAlgorithm, int iterationCount);
++            public void SealWithMac(string password, HashAlgorithmName hashAlgorithm, int iterationCount);
++            public void SealWithoutIntegrity();
++            public bool TryEncode(Span<byte> destination, out int bytesWritten);
++        }
++        public sealed class Pkcs12CertBag : Pkcs12SafeBag {
++            public Pkcs12CertBag(Oid certificateType, ReadOnlyMemory<byte> encodedCertificate);
++            public ReadOnlyMemory<byte> EncodedCertificate { get; }
++            public bool IsX509Certificate { get; }
++            public X509Certificate2 GetCertificate();
++            public Oid GetCertificateType();
++        }
++        public enum Pkcs12ConfidentialityMode {
++            None = 1,
++            Password = 2,
++            PublicKey = 3,
++            Unknown = 0,
++        }
++        public sealed class Pkcs12Info {
++            public ReadOnlyCollection<Pkcs12SafeContents> AuthenticatedSafe { get; }
++            public Pkcs12IntegrityMode IntegrityMode { get; }
++            public static Pkcs12Info Decode(ReadOnlyMemory<byte> encodedBytes, out int bytesConsumed, bool skipCopy = false);
++            public bool VerifyMac(ReadOnlySpan<char> password);
++            public bool VerifyMac(string password);
++        }
++        public enum Pkcs12IntegrityMode {
++            None = 1,
++            Password = 2,
++            PublicKey = 3,
++            Unknown = 0,
++        }
++        public sealed class Pkcs12KeyBag : Pkcs12SafeBag {
++            public Pkcs12KeyBag(ReadOnlyMemory<byte> pkcs8PrivateKey, bool skipCopy = false);
++            public ReadOnlyMemory<byte> Pkcs8PrivateKey { get; }
++        }
++        public abstract class Pkcs12SafeBag {
++            protected Pkcs12SafeBag(string bagIdValue, ReadOnlyMemory<byte> encodedBagValue, bool skipCopy = false);
++            public CryptographicAttributeObjectCollection Attributes { get; }
++            public ReadOnlyMemory<byte> EncodedBagValue { get; }
++            public byte[] Encode();
++            public Oid GetBagId();
++            public bool TryEncode(Span<byte> destination, out int bytesWritten);
++        }
++        public sealed class Pkcs12SafeContents {
++            public Pkcs12SafeContents();
++            public Pkcs12ConfidentialityMode ConfidentialityMode { get; }
++            public bool IsReadOnly { get; }
++            public Pkcs12CertBag AddCertificate(X509Certificate2 certificate);
++            public Pkcs12KeyBag AddKeyUnencrypted(AsymmetricAlgorithm key);
++            public Pkcs12SafeContentsBag AddNestedContents(Pkcs12SafeContents safeContents);
++            public void AddSafeBag(Pkcs12SafeBag safeBag);
++            public Pkcs12SecretBag AddSecret(Oid secretType, ReadOnlyMemory<byte> secretValue);
++            public Pkcs12ShroudedKeyBag AddShroudedKey(AsymmetricAlgorithm key, byte[] passwordBytes, PbeParameters pbeParameters);
++            public Pkcs12ShroudedKeyBag AddShroudedKey(AsymmetricAlgorithm key, ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters);
++            public Pkcs12ShroudedKeyBag AddShroudedKey(AsymmetricAlgorithm key, ReadOnlySpan<char> password, PbeParameters pbeParameters);
++            public Pkcs12ShroudedKeyBag AddShroudedKey(AsymmetricAlgorithm key, string password, PbeParameters pbeParameters);
++            public void Decrypt(byte[] passwordBytes);
++            public void Decrypt(ReadOnlySpan<byte> passwordBytes);
++            public void Decrypt(ReadOnlySpan<char> password);
++            public void Decrypt(string password);
++            public IEnumerable<Pkcs12SafeBag> GetBags();
++        }
++        public sealed class Pkcs12SafeContentsBag : Pkcs12SafeBag {
++            public Pkcs12SafeContents SafeContents { get; }
++        }
++        public sealed class Pkcs12SecretBag : Pkcs12SafeBag {
++            public ReadOnlyMemory<byte> SecretValue { get; }
++            public Oid GetSecretType();
++        }
++        public sealed class Pkcs12ShroudedKeyBag : Pkcs12SafeBag {
++            public Pkcs12ShroudedKeyBag(ReadOnlyMemory<byte> encryptedPkcs8PrivateKey, bool skipCopy = false);
++            public ReadOnlyMemory<byte> EncryptedPkcs8PrivateKey { get; }
++        }
++        public sealed class Pkcs8PrivateKeyInfo {
++            public Pkcs8PrivateKeyInfo(Oid algorithmId, ReadOnlyMemory<byte>? algorithmParameters, ReadOnlyMemory<byte> privateKey, bool skipCopies = false);
++            public Oid AlgorithmId { get; }
++            public ReadOnlyMemory<byte>? AlgorithmParameters { get; }
++            public CryptographicAttributeObjectCollection Attributes { get; }
++            public ReadOnlyMemory<byte> PrivateKeyBytes { get; }
++            public static Pkcs8PrivateKeyInfo Create(AsymmetricAlgorithm privateKey);
++            public static Pkcs8PrivateKeyInfo Decode(ReadOnlyMemory<byte> source, out int bytesRead, bool skipCopy = false);
++            public static Pkcs8PrivateKeyInfo DecryptAndDecode(ReadOnlySpan<byte> passwordBytes, ReadOnlyMemory<byte> source, out int bytesRead);
++            public static Pkcs8PrivateKeyInfo DecryptAndDecode(ReadOnlySpan<char> password, ReadOnlyMemory<byte> source, out int bytesRead);
++            public byte[] Encode();
++            public byte[] Encrypt(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters);
++            public byte[] Encrypt(ReadOnlySpan<char> password, PbeParameters pbeParameters);
++            public bool TryEncode(Span<byte> destination, out int bytesWritten);
++            public bool TryEncrypt(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++            public bool TryEncrypt(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
++        }
++        public sealed class Pkcs9LocalKeyId : Pkcs9AttributeObject {
++            public Pkcs9LocalKeyId();
++            public Pkcs9LocalKeyId(byte[] keyId);
++            public Pkcs9LocalKeyId(ReadOnlySpan<byte> keyId);
++            public ReadOnlyMemory<byte> KeyId { get; }
++        }
+         public sealed class RecipientInfoCollection : ICollection, IEnumerable {
++            public bool IsSynchronized { get; }
++            public object SyncRoot { get; }
+-            bool System.Collections.ICollection.IsSynchronized { get; }
+
+-            object System.Collections.ICollection.SyncRoot { get; }
+
+         }
+         public sealed class SignedCms {
++            public void AddCertificate(X509Certificate2 certificate);
++            public void RemoveCertificate(X509Certificate2 certificate);
+         }
+         public sealed class SignerInfo {
++            public void AddUnsignedAttribute(AsnEncodedData asnEncodedData);
++            public void RemoveUnsignedAttribute(AsnEncodedData asnEncodedData);
+         }
+         public sealed class SubjectIdentifier {
++            public bool MatchesCertificate(X509Certificate2 certificate);
+         }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Security.Cryptography.Xml.md

@@ -0,0 +1,17 @@
+# System.Security.Cryptography.Xml
+
+``` diff
+ {
+     namespace System.Security.Cryptography.Xml {
+         public class SignedXml {
++            public const string XmlDsigRSASHA256Url = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256";
++            public const string XmlDsigRSASHA384Url = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha384";
++            public const string XmlDsigRSASHA512Url = "http://www.w3.org/2001/04/xmldsig-more#rsa-sha512";
++            public const string XmlDsigSHA256Url = "http://www.w3.org/2001/04/xmlenc#sha256";
++            public const string XmlDsigSHA384Url = "http://www.w3.org/2001/04/xmldsig-more#sha384";
++            public const string XmlDsigSHA512Url = "http://www.w3.org/2001/04/xmlenc#sha512";
+         }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Security.Permissions.md

@@ -0,0 +1,260 @@
+# System.Security.Permissions
+
+``` diff
+ {
++    namespace System.Configuration {
++        public sealed class ConfigurationPermission : CodeAccessPermission, IUnrestrictedPermission {
++            public ConfigurationPermission(PermissionState state);
++            public override IPermission Copy();
++            public override void FromXml(SecurityElement securityElement);
++            public override IPermission Intersect(IPermission target);
++            public override bool IsSubsetOf(IPermission target);
++            public bool IsUnrestricted();
++            public override SecurityElement ToXml();
++            public override IPermission Union(IPermission target);
++        }
++        public sealed class ConfigurationPermissionAttribute : CodeAccessSecurityAttribute {
++            public ConfigurationPermissionAttribute(SecurityAction action);
++            public override IPermission CreatePermission();
++        }
++    }
+     namespace System.Security {
+-        public interface IStackWalk {
+ {
+-            void Assert();
+
+-            void Demand();
+
+-            void Deny();
+
+-            void PermitOnly();
+
+-        }
+-        public class PermissionSet : ICollection, IDeserializationCallback, IEnumerable, ISecurityEncodable, IStackWalk {
+ {
+-            public PermissionSet(PermissionState state);
+
+-            public PermissionSet(PermissionSet permSet);
+
+-            public virtual int Count { get; }
+
+-            public virtual bool IsReadOnly { get; }
+
+-            public virtual bool IsSynchronized { get; }
+
+-            public virtual object SyncRoot { get; }
+
+-            public IPermission AddPermission(IPermission perm);
+
+-            protected virtual IPermission AddPermissionImpl(IPermission perm);
+
+-            public void Assert();
+
+-            public bool ContainsNonCodeAccessPermissions();
+
+-            public static byte[] ConvertPermissionSet(string inFormat, byte[] inData, string outFormat);
+
+-            public virtual PermissionSet Copy();
+
+-            public virtual void CopyTo(Array array, int index);
+
+-            public void Demand();
+
+-            public void Deny();
+
+-            public override bool Equals(object o);
+
+-            public virtual void FromXml(SecurityElement et);
+
+-            public IEnumerator GetEnumerator();
+
+-            protected virtual IEnumerator GetEnumeratorImpl();
+
+-            public override int GetHashCode();
+
+-            public IPermission GetPermission(Type permClass);
+
+-            protected virtual IPermission GetPermissionImpl(Type permClass);
+
+-            public PermissionSet Intersect(PermissionSet other);
+
+-            public bool IsEmpty();
+
+-            public bool IsSubsetOf(PermissionSet target);
+
+-            public bool IsUnrestricted();
+
+-            public void PermitOnly();
+
+-            public IPermission RemovePermission(Type permClass);
+
+-            protected virtual IPermission RemovePermissionImpl(Type permClass);
+
+-            public static void RevertAssert();
+
+-            public IPermission SetPermission(IPermission perm);
+
+-            protected virtual IPermission SetPermissionImpl(IPermission perm);
+
+-            void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender);
+
+-            public override string ToString();
+
+-            public virtual SecurityElement ToXml();
+
+-            public PermissionSet Union(PermissionSet other);
+
+-        }
+     }
+     namespace System.Security.Permissions {
++        public sealed class DataProtectionPermission : CodeAccessPermission, IUnrestrictedPermission {
++            public DataProtectionPermission(DataProtectionPermissionFlags flag);
++            public DataProtectionPermission(PermissionState state);
++            public DataProtectionPermissionFlags Flags { get; set; }
++            public override IPermission Copy();
++            public override void FromXml(SecurityElement securityElement);
++            public override IPermission Intersect(IPermission target);
++            public override bool IsSubsetOf(IPermission target);
++            public bool IsUnrestricted();
++            public override SecurityElement ToXml();
++            public override IPermission Union(IPermission target);
++        }
++        public sealed class DataProtectionPermissionAttribute : CodeAccessSecurityAttribute {
++            public DataProtectionPermissionAttribute(SecurityAction action);
++            public DataProtectionPermissionFlags Flags { get; set; }
++            public bool ProtectData { get; set; }
++            public bool ProtectMemory { get; set; }
++            public bool UnprotectData { get; set; }
++            public bool UnprotectMemory { get; set; }
++            public override IPermission CreatePermission();
++        }
++        public enum DataProtectionPermissionFlags {
++            AllFlags = 15,
++            NoFlags = 0,
++            ProtectData = 1,
++            ProtectMemory = 4,
++            UnprotectData = 2,
++            UnprotectMemory = 8,
++        }
++        public sealed class MediaPermission : CodeAccessPermission, IUnrestrictedPermission {
++            public MediaPermission();
++            public MediaPermission(MediaPermissionAudio permissionAudio);
++            public MediaPermission(MediaPermissionAudio permissionAudio, MediaPermissionVideo permissionVideo, MediaPermissionImage permissionImage);
++            public MediaPermission(MediaPermissionImage permissionImage);
++            public MediaPermission(MediaPermissionVideo permissionVideo);
++            public MediaPermission(PermissionState state);
++            public MediaPermissionAudio Audio { get; }
++            public MediaPermissionImage Image { get; }
++            public MediaPermissionVideo Video { get; }
++            public override IPermission Copy();
++            public override void FromXml(SecurityElement securityElement);
++            public override IPermission Intersect(IPermission target);
++            public override bool IsSubsetOf(IPermission target);
++            public bool IsUnrestricted();
++            public override SecurityElement ToXml();
++            public override IPermission Union(IPermission target);
++        }
++        public sealed class MediaPermissionAttribute : CodeAccessSecurityAttribute {
++            public MediaPermissionAttribute(SecurityAction action);
++            public MediaPermissionAudio Audio { get; set; }
++            public MediaPermissionImage Image { get; set; }
++            public MediaPermissionVideo Video { get; set; }
++            public override IPermission CreatePermission();
++        }
++        public enum MediaPermissionAudio {
++            AllAudio = 3,
++            NoAudio = 0,
++            SafeAudio = 2,
++            SiteOfOriginAudio = 1,
++        }
++        public enum MediaPermissionImage {
++            AllImage = 3,
++            NoImage = 0,
++            SafeImage = 2,
++            SiteOfOriginImage = 1,
++        }
++        public enum MediaPermissionVideo {
++            AllVideo = 3,
++            NoVideo = 0,
++            SafeVideo = 2,
++            SiteOfOriginVideo = 1,
++        }
+-        public enum PermissionState {
+ {
+-            None = 0,
+
+-            Unrestricted = 1,
+
+-        }
++        public sealed class WebBrowserPermission : CodeAccessPermission, IUnrestrictedPermission {
++            public WebBrowserPermission();
++            public WebBrowserPermission(PermissionState state);
++            public WebBrowserPermission(WebBrowserPermissionLevel webBrowserPermissionLevel);
++            public WebBrowserPermissionLevel Level { get; set; }
++            public override IPermission Copy();
++            public override void FromXml(SecurityElement securityElement);
++            public override IPermission Intersect(IPermission target);
++            public override bool IsSubsetOf(IPermission target);
++            public bool IsUnrestricted();
++            public override SecurityElement ToXml();
++            public override IPermission Union(IPermission target);
++        }
++        public sealed class WebBrowserPermissionAttribute : CodeAccessSecurityAttribute {
++            public WebBrowserPermissionAttribute(SecurityAction action);
++            public WebBrowserPermissionLevel Level { get; set; }
++            public override IPermission CreatePermission();
++        }
++        public enum WebBrowserPermissionLevel {
++            None = 0,
++            Safe = 1,
++            Unrestricted = 2,
++        }
+     }
++    namespace System.Web {
++        public sealed class AspNetHostingPermission : CodeAccessPermission, IUnrestrictedPermission {
++            public AspNetHostingPermission(PermissionState state);
++            public AspNetHostingPermission(AspNetHostingPermissionLevel level);
++            public AspNetHostingPermissionLevel Level { get; set; }
++            public override IPermission Copy();
++            public override void FromXml(SecurityElement securityElement);
++            public override IPermission Intersect(IPermission target);
++            public override bool IsSubsetOf(IPermission target);
++            public bool IsUnrestricted();
++            public override SecurityElement ToXml();
++            public override IPermission Union(IPermission target);
++        }
++        public sealed class AspNetHostingPermissionAttribute : CodeAccessSecurityAttribute {
++            public AspNetHostingPermissionAttribute(SecurityAction action);
++            public AspNetHostingPermissionLevel Level { get; set; }
++            public override IPermission CreatePermission();
++        }
++        public enum AspNetHostingPermissionLevel {
++            High = 500,
++            Low = 300,
++            Medium = 400,
++            Minimal = 200,
++            None = 100,
++            Unrestricted = 600,
++        }
++    }
++    namespace System.Xaml.Permissions {
++        public sealed class XamlLoadPermission : CodeAccessPermission, IUnrestrictedPermission {
++            public XamlLoadPermission(IEnumerable<XamlAccessLevel> allowedAccess);
++            public XamlLoadPermission(PermissionState state);
++            public XamlLoadPermission(XamlAccessLevel allowedAccess);
++            public IList<XamlAccessLevel> AllowedAccess { get; }
++            public override IPermission Copy();
++            public override bool Equals(object obj);
++            public override void FromXml(SecurityElement elem);
++            public override int GetHashCode();
++            public bool Includes(XamlAccessLevel requestedAccess);
++            public override IPermission Intersect(IPermission target);
++            public override bool IsSubsetOf(IPermission target);
++            public bool IsUnrestricted();
++            public override SecurityElement ToXml();
++            public override IPermission Union(IPermission other);
++        }
++    }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Security.Principal.Windows.md

@@ -0,0 +1,19 @@
+# System.Security.Principal.Windows
+
+``` diff
+ {
+     namespace System.Security.Principal {
++        public enum WindowsAccountType {
++            Anonymous = 3,
++            Guest = 1,
++            Normal = 0,
++            System = 2,
++        }
+         public class WindowsIdentity : ClaimsIdentity, IDeserializationCallback, IDisposable, ISerializable {
++            public WindowsIdentity(IntPtr userToken, string type, WindowsAccountType acctType);
++            public WindowsIdentity(IntPtr userToken, string type, WindowsAccountType acctType, bool isAuthenticated);
+         }
+     }
+ }
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Text.Encoding.CodePages.md

@@ -0,0 +1,20 @@
+# System.Text.Encoding.CodePages
+
+``` diff
+ {
+ {
+-    namespace System.Text {
+ {
+-        public sealed class CodePagesEncodingProvider : EncodingProvider {
+ {
+-            public static EncodingProvider Instance { get; }
+
+-            public override Encoding GetEncoding(int codepage);
+
+-            public override Encoding GetEncoding(string name);
+
+-        }
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Text.Encodings.Web.md

@@ -0,0 +1,429 @@
+# System.Text.Encodings.Web
+
+``` diff
+ {
+ {
+-    namespace System.Text.Encodings.Web {
+ {
+-        public abstract class HtmlEncoder : TextEncoder {
+ {
+-            protected HtmlEncoder();
+
+-            public static HtmlEncoder Default { get; }
+
+-            public static HtmlEncoder Create(TextEncoderSettings settings);
+
+-            public static HtmlEncoder Create(params UnicodeRange[] allowedRanges);
+
+-        }
+-        public abstract class JavaScriptEncoder : TextEncoder {
+ {
+-            protected JavaScriptEncoder();
+
+-            public static JavaScriptEncoder Default { get; }
+
+-            public static JavaScriptEncoder Create(TextEncoderSettings settings);
+
+-            public static JavaScriptEncoder Create(params UnicodeRange[] allowedRanges);
+
+-        }
+-        public abstract class TextEncoder {
+ {
+-            protected TextEncoder();
+
+-            public abstract int MaxOutputCharactersPerInputCharacter { get; }
+
+-            public virtual void Encode(TextWriter output, char[] value, int startIndex, int characterCount);
+
+-            public void Encode(TextWriter output, string value);
+
+-            public virtual void Encode(TextWriter output, string value, int startIndex, int characterCount);
+
+-            public virtual string Encode(string value);
+
+-            public unsafe abstract int FindFirstCharacterToEncode(char* text, int textLength);
+
+-            public unsafe abstract bool TryEncodeUnicodeScalar(int unicodeScalar, char* buffer, int bufferLength, out int numberOfCharactersWritten);
+
+-            public abstract bool WillEncode(int unicodeScalar);
+
+-        }
+-        public class TextEncoderSettings {
+ {
+-            public TextEncoderSettings();
+
+-            public TextEncoderSettings(TextEncoderSettings other);
+
+-            public TextEncoderSettings(params UnicodeRange[] allowedRanges);
+
+-            public virtual void AllowCharacter(char character);
+
+-            public virtual void AllowCharacters(params char[] characters);
+
+-            public virtual void AllowCodePoints(IEnumerable<int> codePoints);
+
+-            public virtual void AllowRange(UnicodeRange range);
+
+-            public virtual void AllowRanges(params UnicodeRange[] ranges);
+
+-            public virtual void Clear();
+
+-            public virtual void ForbidCharacter(char character);
+
+-            public virtual void ForbidCharacters(params char[] characters);
+
+-            public virtual void ForbidRange(UnicodeRange range);
+
+-            public virtual void ForbidRanges(params UnicodeRange[] ranges);
+
+-            public virtual IEnumerable<int> GetAllowedCodePoints();
+
+-        }
+-        public abstract class UrlEncoder : TextEncoder {
+ {
+-            protected UrlEncoder();
+
+-            public static UrlEncoder Default { get; }
+
+-            public static UrlEncoder Create(TextEncoderSettings settings);
+
+-            public static UrlEncoder Create(params UnicodeRange[] allowedRanges);
+
+-        }
+-    }
+-    namespace System.Text.Unicode {
+ {
+-        public sealed class UnicodeRange {
+ {
+-            public UnicodeRange(int firstCodePoint, int length);
+
+-            public int FirstCodePoint { get; private set; }
+
+-            public int Length { get; private set; }
+
+-            public static UnicodeRange Create(char firstCharacter, char lastCharacter);
+
+-        }
+-        public static class UnicodeRanges {
+ {
+-            public static UnicodeRange All { get; }
+
+-            public static UnicodeRange AlphabeticPresentationForms { get; }
+
+-            public static UnicodeRange Arabic { get; }
+
+-            public static UnicodeRange ArabicExtendedA { get; }
+
+-            public static UnicodeRange ArabicPresentationFormsA { get; }
+
+-            public static UnicodeRange ArabicPresentationFormsB { get; }
+
+-            public static UnicodeRange ArabicSupplement { get; }
+
+-            public static UnicodeRange Armenian { get; }
+
+-            public static UnicodeRange Arrows { get; }
+
+-            public static UnicodeRange Balinese { get; }
+
+-            public static UnicodeRange Bamum { get; }
+
+-            public static UnicodeRange BasicLatin { get; }
+
+-            public static UnicodeRange Batak { get; }
+
+-            public static UnicodeRange Bengali { get; }
+
+-            public static UnicodeRange BlockElements { get; }
+
+-            public static UnicodeRange Bopomofo { get; }
+
+-            public static UnicodeRange BopomofoExtended { get; }
+
+-            public static UnicodeRange BoxDrawing { get; }
+
+-            public static UnicodeRange BraillePatterns { get; }
+
+-            public static UnicodeRange Buginese { get; }
+
+-            public static UnicodeRange Buhid { get; }
+
+-            public static UnicodeRange Cham { get; }
+
+-            public static UnicodeRange Cherokee { get; }
+
+-            public static UnicodeRange CherokeeSupplement { get; }
+
+-            public static UnicodeRange CjkCompatibility { get; }
+
+-            public static UnicodeRange CjkCompatibilityForms { get; }
+
+-            public static UnicodeRange CjkCompatibilityIdeographs { get; }
+
+-            public static UnicodeRange CjkRadicalsSupplement { get; }
+
+-            public static UnicodeRange CjkStrokes { get; }
+
+-            public static UnicodeRange CjkSymbolsandPunctuation { get; }
+
+-            public static UnicodeRange CjkUnifiedIdeographs { get; }
+
+-            public static UnicodeRange CjkUnifiedIdeographsExtensionA { get; }
+
+-            public static UnicodeRange CombiningDiacriticalMarks { get; }
+
+-            public static UnicodeRange CombiningDiacriticalMarksExtended { get; }
+
+-            public static UnicodeRange CombiningDiacriticalMarksforSymbols { get; }
+
+-            public static UnicodeRange CombiningDiacriticalMarksSupplement { get; }
+
+-            public static UnicodeRange CombiningHalfMarks { get; }
+
+-            public static UnicodeRange CommonIndicNumberForms { get; }
+
+-            public static UnicodeRange ControlPictures { get; }
+
+-            public static UnicodeRange Coptic { get; }
+
+-            public static UnicodeRange CurrencySymbols { get; }
+
+-            public static UnicodeRange Cyrillic { get; }
+
+-            public static UnicodeRange CyrillicExtendedA { get; }
+
+-            public static UnicodeRange CyrillicExtendedB { get; }
+
+-            public static UnicodeRange CyrillicSupplement { get; }
+
+-            public static UnicodeRange Devanagari { get; }
+
+-            public static UnicodeRange DevanagariExtended { get; }
+
+-            public static UnicodeRange Dingbats { get; }
+
+-            public static UnicodeRange EnclosedAlphanumerics { get; }
+
+-            public static UnicodeRange EnclosedCjkLettersandMonths { get; }
+
+-            public static UnicodeRange Ethiopic { get; }
+
+-            public static UnicodeRange EthiopicExtended { get; }
+
+-            public static UnicodeRange EthiopicExtendedA { get; }
+
+-            public static UnicodeRange EthiopicSupplement { get; }
+
+-            public static UnicodeRange GeneralPunctuation { get; }
+
+-            public static UnicodeRange GeometricShapes { get; }
+
+-            public static UnicodeRange Georgian { get; }
+
+-            public static UnicodeRange GeorgianSupplement { get; }
+
+-            public static UnicodeRange Glagolitic { get; }
+
+-            public static UnicodeRange GreekandCoptic { get; }
+
+-            public static UnicodeRange GreekExtended { get; }
+
+-            public static UnicodeRange Gujarati { get; }
+
+-            public static UnicodeRange Gurmukhi { get; }
+
+-            public static UnicodeRange HalfwidthandFullwidthForms { get; }
+
+-            public static UnicodeRange HangulCompatibilityJamo { get; }
+
+-            public static UnicodeRange HangulJamo { get; }
+
+-            public static UnicodeRange HangulJamoExtendedA { get; }
+
+-            public static UnicodeRange HangulJamoExtendedB { get; }
+
+-            public static UnicodeRange HangulSyllables { get; }
+
+-            public static UnicodeRange Hanunoo { get; }
+
+-            public static UnicodeRange Hebrew { get; }
+
+-            public static UnicodeRange Hiragana { get; }
+
+-            public static UnicodeRange IdeographicDescriptionCharacters { get; }
+
+-            public static UnicodeRange IpaExtensions { get; }
+
+-            public static UnicodeRange Javanese { get; }
+
+-            public static UnicodeRange Kanbun { get; }
+
+-            public static UnicodeRange KangxiRadicals { get; }
+
+-            public static UnicodeRange Kannada { get; }
+
+-            public static UnicodeRange Katakana { get; }
+
+-            public static UnicodeRange KatakanaPhoneticExtensions { get; }
+
+-            public static UnicodeRange KayahLi { get; }
+
+-            public static UnicodeRange Khmer { get; }
+
+-            public static UnicodeRange KhmerSymbols { get; }
+
+-            public static UnicodeRange Lao { get; }
+
+-            public static UnicodeRange Latin1Supplement { get; }
+
+-            public static UnicodeRange LatinExtendedA { get; }
+
+-            public static UnicodeRange LatinExtendedAdditional { get; }
+
+-            public static UnicodeRange LatinExtendedB { get; }
+
+-            public static UnicodeRange LatinExtendedC { get; }
+
+-            public static UnicodeRange LatinExtendedD { get; }
+
+-            public static UnicodeRange LatinExtendedE { get; }
+
+-            public static UnicodeRange Lepcha { get; }
+
+-            public static UnicodeRange LetterlikeSymbols { get; }
+
+-            public static UnicodeRange Limbu { get; }
+
+-            public static UnicodeRange Lisu { get; }
+
+-            public static UnicodeRange Malayalam { get; }
+
+-            public static UnicodeRange Mandaic { get; }
+
+-            public static UnicodeRange MathematicalOperators { get; }
+
+-            public static UnicodeRange MeeteiMayek { get; }
+
+-            public static UnicodeRange MeeteiMayekExtensions { get; }
+
+-            public static UnicodeRange MiscellaneousMathematicalSymbolsA { get; }
+
+-            public static UnicodeRange MiscellaneousMathematicalSymbolsB { get; }
+
+-            public static UnicodeRange MiscellaneousSymbols { get; }
+
+-            public static UnicodeRange MiscellaneousSymbolsandArrows { get; }
+
+-            public static UnicodeRange MiscellaneousTechnical { get; }
+
+-            public static UnicodeRange ModifierToneLetters { get; }
+
+-            public static UnicodeRange Mongolian { get; }
+
+-            public static UnicodeRange Myanmar { get; }
+
+-            public static UnicodeRange MyanmarExtendedA { get; }
+
+-            public static UnicodeRange MyanmarExtendedB { get; }
+
+-            public static UnicodeRange NewTaiLue { get; }
+
+-            public static UnicodeRange NKo { get; }
+
+-            public static UnicodeRange None { get; }
+
+-            public static UnicodeRange NumberForms { get; }
+
+-            public static UnicodeRange Ogham { get; }
+
+-            public static UnicodeRange OlChiki { get; }
+
+-            public static UnicodeRange OpticalCharacterRecognition { get; }
+
+-            public static UnicodeRange Oriya { get; }
+
+-            public static UnicodeRange Phagspa { get; }
+
+-            public static UnicodeRange PhoneticExtensions { get; }
+
+-            public static UnicodeRange PhoneticExtensionsSupplement { get; }
+
+-            public static UnicodeRange Rejang { get; }
+
+-            public static UnicodeRange Runic { get; }
+
+-            public static UnicodeRange Samaritan { get; }
+
+-            public static UnicodeRange Saurashtra { get; }
+
+-            public static UnicodeRange Sinhala { get; }
+
+-            public static UnicodeRange SmallFormVariants { get; }
+
+-            public static UnicodeRange SpacingModifierLetters { get; }
+
+-            public static UnicodeRange Specials { get; }
+
+-            public static UnicodeRange Sundanese { get; }
+
+-            public static UnicodeRange SundaneseSupplement { get; }
+
+-            public static UnicodeRange SuperscriptsandSubscripts { get; }
+
+-            public static UnicodeRange SupplementalArrowsA { get; }
+
+-            public static UnicodeRange SupplementalArrowsB { get; }
+
+-            public static UnicodeRange SupplementalMathematicalOperators { get; }
+
+-            public static UnicodeRange SupplementalPunctuation { get; }
+
+-            public static UnicodeRange SylotiNagri { get; }
+
+-            public static UnicodeRange Syriac { get; }
+
+-            public static UnicodeRange Tagalog { get; }
+
+-            public static UnicodeRange Tagbanwa { get; }
+
+-            public static UnicodeRange TaiLe { get; }
+
+-            public static UnicodeRange TaiTham { get; }
+
+-            public static UnicodeRange TaiViet { get; }
+
+-            public static UnicodeRange Tamil { get; }
+
+-            public static UnicodeRange Telugu { get; }
+
+-            public static UnicodeRange Thaana { get; }
+
+-            public static UnicodeRange Thai { get; }
+
+-            public static UnicodeRange Tibetan { get; }
+
+-            public static UnicodeRange Tifinagh { get; }
+
+-            public static UnicodeRange UnifiedCanadianAboriginalSyllabics { get; }
+
+-            public static UnicodeRange UnifiedCanadianAboriginalSyllabicsExtended { get; }
+
+-            public static UnicodeRange Vai { get; }
+
+-            public static UnicodeRange VariationSelectors { get; }
+
+-            public static UnicodeRange VedicExtensions { get; }
+
+-            public static UnicodeRange VerticalForms { get; }
+
+-            public static UnicodeRange YijingHexagramSymbols { get; }
+
+-            public static UnicodeRange YiRadicals { get; }
+
+-            public static UnicodeRange YiSyllables { get; }
+
+-        }
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Threading.Channels.md

@@ -0,0 +1,115 @@
+# System.Threading.Channels
+
+``` diff
+ {
+ {
+-    namespace System.Threading.Channels {
+ {
+-        public enum BoundedChannelFullMode {
+ {
+-            DropNewest = 1,
+
+-            DropOldest = 2,
+
+-            DropWrite = 3,
+
+-            Wait = 0,
+
+-        }
+-        public sealed class BoundedChannelOptions : ChannelOptions {
+ {
+-            public BoundedChannelOptions(int capacity);
+
+-            public int Capacity { get; set; }
+
+-            public BoundedChannelFullMode FullMode { get; set; }
+
+-        }
+-        public static class Channel {
+ {
+-            public static Channel<T> CreateBounded<T>(int capacity);
+
+-            public static Channel<T> CreateBounded<T>(BoundedChannelOptions options);
+
+-            public static Channel<T> CreateUnbounded<T>();
+
+-            public static Channel<T> CreateUnbounded<T>(UnboundedChannelOptions options);
+
+-        }
+-        public abstract class Channel<T> : Channel<T, T> {
+ {
+-            protected Channel();
+
+-        }
+-        public abstract class Channel<TWrite, TRead> {
+ {
+-            protected Channel();
+
+-            public ChannelReader<TRead> Reader { get; protected set; }
+
+-            public ChannelWriter<TWrite> Writer { get; protected set; }
+
+-            public static implicit operator ChannelReader<TRead> (Channel<TWrite, TRead> channel);
+
+-            public static implicit operator ChannelWriter<TWrite> (Channel<TWrite, TRead> channel);
+
+-        }
+-        public class ChannelClosedException : InvalidOperationException {
+ {
+-            public ChannelClosedException();
+
+-            public ChannelClosedException(Exception innerException);
+
+-            public ChannelClosedException(string message);
+
+-            public ChannelClosedException(string message, Exception innerException);
+
+-        }
+-        public abstract class ChannelOptions {
+ {
+-            protected ChannelOptions();
+
+-            public bool AllowSynchronousContinuations { get; set; }
+
+-            public bool SingleReader { get; set; }
+
+-            public bool SingleWriter { get; set; }
+
+-        }
+-        public abstract class ChannelReader<T> {
+ {
+-            protected ChannelReader();
+
+-            public virtual Task Completion { get; }
+
+-            public virtual ValueTask<T> ReadAsync(CancellationToken cancellationToken = default(CancellationToken));
+
+-            public abstract bool TryRead(out T item);
+
+-            public abstract ValueTask<bool> WaitToReadAsync(CancellationToken cancellationToken = default(CancellationToken));
+
+-        }
+-        public abstract class ChannelWriter<T> {
+ {
+-            protected ChannelWriter();
+
+-            public void Complete(Exception error = null);
+
+-            public virtual bool TryComplete(Exception error = null);
+
+-            public abstract bool TryWrite(T item);
+
+-            public abstract ValueTask<bool> WaitToWriteAsync(CancellationToken cancellationToken = default(CancellationToken));
+
+-            public virtual ValueTask WriteAsync(T item, CancellationToken cancellationToken = default(CancellationToken));
+
+-        }
+-        public sealed class UnboundedChannelOptions : ChannelOptions {
+ {
+-            public UnboundedChannelOptions();
+
+-        }
+-    }
+-}
+```
+

release-notes/3.0/preview/api-diff/3.0 vs 2.2/standalone-packages/3.0.0-standalone-packages_System.Windows.Extensions.md

@@ -0,0 +1,128 @@
+# System.Windows.Extensions
+
+``` diff
+ {
++    namespace System.Drawing {
++        public class FontConverter : TypeConverter {
++            public FontConverter();
++            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++            public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues);
++            public override bool GetCreateInstanceSupported(ITypeDescriptorContext context);
++            public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes);
++            public override bool GetPropertiesSupported(ITypeDescriptorContext context);
++            public sealed class FontNameConverter : TypeConverter, IDisposable {
++                public FontNameConverter();
++                public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++                public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++                public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
++                public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
++                public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
++                void System.IDisposable.Dispose();
++            }
++            public class FontUnitConverter : EnumConverter {
++                public FontUnitConverter();
++                public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
++            }
++        }
++        public class IconConverter : ExpandableObjectConverter {
++            public IconConverter();
++            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        }
++        public class ImageConverter : TypeConverter {
++            public ImageConverter();
++            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++            public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes);
++            public override bool GetPropertiesSupported(ITypeDescriptorContext context);
++        }
++        public class ImageFormatConverter : TypeConverter {
++            public ImageFormatConverter();
++            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++            public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
++            public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
++        }
++    }
++    namespace System.Drawing.Printing {
++        public class MarginsConverter : ExpandableObjectConverter {
++            public MarginsConverter();
++            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++            public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues);
++            public override bool GetCreateInstanceSupported(ITypeDescriptorContext context);
++        }
++    }
++    namespace System.Media {
++        public class SoundPlayer : Component, ISerializable {
++            public SoundPlayer();
++            public SoundPlayer(Stream stream);
++            protected SoundPlayer(SerializationInfo serializationInfo, StreamingContext context);
++            public SoundPlayer(string soundLocation);
++            public bool IsLoadCompleted { get; }
++            public int LoadTimeout { get; set; }
++            public string SoundLocation { get; set; }
++            public Stream Stream { get; set; }
++            public object Tag { get; set; }
++            public event AsyncCompletedEventHandler LoadCompleted;
++            public event EventHandler SoundLocationChanged;
++            public event EventHandler StreamChanged;
++            public void Load();
++            public void LoadAsync();
++            protected virtual void OnLoadCompleted(AsyncCompletedEventArgs e);
++            protected virtual void OnSoundLocationChanged(EventArgs e);
++            protected virtual void OnStreamChanged(EventArgs e);
++            public void Play();
++            public void PlayLooping();
++            public void PlaySync();
++            public void Stop();
++            void System.Runtime.Serialization.ISerializable.GetObjectData(SerializationInfo info, StreamingContext context);
++        }
++        public class SystemSound {
++            public void Play();
++        }
++        public static class SystemSounds {
++            public static SystemSound Asterisk { get; }
++            public static SystemSound Beep { get; }
++            public static SystemSound Exclamation { get; }
++            public static SystemSound Hand { get; }
++            public static SystemSound Question { get; }
++        }
++    }
++    namespace System.Security.Cryptography.X509Certificates {
++        public sealed class X509Certificate2UI {
++            public X509Certificate2UI();
++            public static void DisplayCertificate(X509Certificate2 certificate);
++            public static void DisplayCertificate(X509Certificate2 certificate, IntPtr hwndParent);
++            public static X509Certificate2Collection SelectFromCollection(X509Certificate2Collection certificates, string title, string message, X509SelectionFlag selectionFlag);
++            public static X509Certificate2Collection SelectFromCollection(X509Certificate2Collection certificates, string title, string message, X509SelectionFlag selectionFlag, IntPtr hwndParent);
++        }
++        public enum X509SelectionFlag {
++            MultiSelection = 1,
++            SingleSelection = 0,
++        }
++    }
++    namespace System.Xaml.Permissions {
++        public class XamlAccessLevel {
++            public AssemblyName AssemblyAccessToAssemblyName { get; }
++            public string PrivateAccessToTypeName { get; }
++            public static XamlAccessLevel AssemblyAccessTo(Assembly assembly);
++            public static XamlAccessLevel AssemblyAccessTo(AssemblyName assemblyName);
++            public static XamlAccessLevel PrivateAccessTo(string assemblyQualifiedTypeName);
++            public static XamlAccessLevel PrivateAccessTo(Type type);
++        }
++    }
++}
+```
+