API-diff between 7.0-preview4 and 7.0-preview5 (#7587)

* API-diff between 7.0-preview4 and 7.0-preview5

* Apply suggestions from code review

Co-authored-by: Brennan <brecon@microsoft.com>
Co-authored-by: Tanner Gooding <tagoo@outlook.com>

Co-authored-by: carlossanlop <carlossanlop@users.noreply.github.com>
Co-authored-by: Brennan <brecon@microsoft.com>
Co-authored-by: Tanner Gooding <tagoo@outlook.com>

52 files changed, 2774 insertions, 0 deletions

diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md
new file mode 100644
index 00000000..015e5407
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5.md
@@ -0,0 +1,22 @@
+# API Difference 7.0-preview4 vs 7.0-preview5
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Authentication](7.0-preview5_Microsoft.AspNetCore.Authentication.md)
+* [Microsoft.AspNetCore.Authorization.Infrastructure](7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md)
+* [Microsoft.AspNetCore.Builder](7.0-preview5_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.DataProtection](7.0-preview5_Microsoft.AspNetCore.DataProtection.md)
+* [Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel](7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md)
+* [Microsoft.AspNetCore.DataProtection.Internal](7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md)
+* [Microsoft.AspNetCore.DataProtection.KeyManagement](7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md)
+* [Microsoft.AspNetCore.DataProtection.KeyManagement.Internal](7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md)
+* [Microsoft.AspNetCore.Http](7.0-preview5_Microsoft.AspNetCore.Http.md)
+* [Microsoft.AspNetCore.Http.HttpResults](7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md)
+* [Microsoft.AspNetCore.Mvc](7.0-preview5_Microsoft.AspNetCore.Mvc.md)
+* [Microsoft.AspNetCore.ResponseCompression](7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md)
+* [Microsoft.AspNetCore.SignalR](7.0-preview5_Microsoft.AspNetCore.SignalR.md)
+* [Microsoft.AspNetCore.WebUtilities](7.0-preview5_Microsoft.AspNetCore.WebUtilities.md)
+* [Microsoft.Extensions.Logging](7.0-preview5_Microsoft.Extensions.Logging.md)
+* [Microsoft.JSInterop.Infrastructure](7.0-preview5_Microsoft.JSInterop.Infrastructure.md)
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md
new file mode 100644
index 00000000..bf591034
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authentication.md
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Authentication
+
+``` diff
+ namespace Microsoft.AspNetCore.Authentication {
++    public interface IAuthenticationConfigurationProvider {
++        IConfiguration GetAuthenticationSchemeConfiguration(string authenticationScheme);
++    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md
new file mode 100644
index 00000000..1629ecc0
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Authorization.Infrastructure.md
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Authorization.Infrastructure
+
+``` diff
+ namespace Microsoft.AspNetCore.Authorization.Infrastructure {
+     public class PassThroughAuthorizationHandler : IAuthorizationHandler {
++        public PassThroughAuthorizationHandler(IOptions<AuthorizationOptions> options);
+         public Task HandleAsync(AuthorizationHandlerContext context);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md
new file mode 100644
index 00000000..686039f8
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Builder.md
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
+     public sealed class WebApplicationBuilder {
++        public AuthenticationBuilder Authentication { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md
new file mode 100644
index 00000000..2a2ddb5d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.md
@@ -0,0 +1,27 @@
+# Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel {
+-    [RequiresUnreferencedCode(TrimmerWarning.Message)]
+     public sealed class AuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer {
+         public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+     public sealed class CngCbcAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+     public sealed class CngGcmAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+     public interface IAuthenticatedEncryptorDescriptorDeserializer {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+     public sealed class ManagedAuthenticatedEncryptorDescriptorDeserializer : IAuthenticatedEncryptorDescriptorDeserializer {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public IAuthenticatedEncryptorDescriptor ImportFromXml(XElement element);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md
new file mode 100644
index 00000000..75be7596
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.Internal.md
@@ -0,0 +1,12 @@
+# Microsoft.AspNetCore.DataProtection.Internal
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.Internal {
+     public interface IActivator {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+-        object CreateInstance(Type expectedBaseType, string implementationTypeName);
++        object CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type expectedBaseType, string implementationTypeName);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md
new file mode 100644
index 00000000..21d38681
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.Internal.md
@@ -0,0 +1,19 @@
+# Microsoft.AspNetCore.DataProtection.KeyManagement.Internal
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.KeyManagement.Internal {
+     public interface ICacheableKeyRingProvider {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         CacheableKeyRing GetCacheableKeyRing(DateTimeOffset now);
+     }
+     public interface IInternalXmlKeyManager {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IAuthenticatedEncryptorDescriptor DeserializeDescriptorFromKeyElement(XElement keyElement);
+     }
+     public interface IKeyRingProvider {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IKeyRing GetCurrentKeyRing();
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md
new file mode 100644
index 00000000..6d7a711b
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.KeyManagement.md
@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.DataProtection.KeyManagement
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.KeyManagement {
+     public interface IKeyManager {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IReadOnlyCollection<IKey> GetAllKeys();
+     }
+     public sealed class XmlKeyManager : IInternalXmlKeyManager, IKeyManager {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public IReadOnlyCollection<IKey> GetAllKeys();
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         IAuthenticatedEncryptorDescriptor IInternalXmlKeyManager.DeserializeDescriptorFromKeyElement(XElement keyElement);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md
new file mode 100644
index 00000000..203479c2
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.DataProtection.md
@@ -0,0 +1,39 @@
+# Microsoft.AspNetCore.DataProtection
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection {
+     public static class DataProtectionAdvancedExtensions {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static byte[] Protect(this ITimeLimitedDataProtector protector, byte[] plaintext, TimeSpan lifetime);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Protect(this ITimeLimitedDataProtector protector, string plaintext, DateTimeOffset expiration);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Protect(this ITimeLimitedDataProtector protector, string plaintext, TimeSpan lifetime);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Unprotect(this ITimeLimitedDataProtector protector, string protectedData, out DateTimeOffset expiration);
+     }
+     public static class DataProtectionCommonExtensions {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Protect(this IDataProtector protector, string plaintext);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         public static string Unprotect(this IDataProtector protector, string protectedData);
+     }
+     public interface IDataProtector : IDataProtectionProvider {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] Protect(byte[] plaintext);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] Unprotect(byte[] protectedData);
+     }
+     public interface IPersistedDataProtector : IDataProtectionProvider, IDataProtector {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] DangerousUnprotect(byte[] protectedData, bool ignoreRevocationErrors, out bool requiresMigration, out bool wasRevoked);
+     }
+     public interface ITimeLimitedDataProtector : IDataProtectionProvider, IDataProtector {
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] Protect(byte[] plaintext, DateTimeOffset expiration);
+-        [RequiresUnreferencedCode(TrimmerWarning.Message)]
+         byte[] Unprotect(byte[] protectedData, out DateTimeOffset expiration);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md
new file mode 100644
index 00000000..4dc03c2f
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.HttpResults.md
@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Http.HttpResults
+
+``` diff
+- namespace Microsoft.AspNetCore.Http {
++ namespace Microsoft.AspNetCore.Http.HttpResults {
+     public sealed class ChallengeHttpResult : IResult {
+         public Task ExecuteAsync(HttpContext httpContext);
+     }
+     public sealed class ForbidHttpResult : IResult {
+         public Task ExecuteAsync(HttpContext httpContext);
+     }
+     public sealed class SignOutHttpResult : IResult {
+         public Task ExecuteAsync(HttpContext httpContext);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md
new file mode 100644
index 00000000..164dcd07
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Http.md
@@ -0,0 +1,92 @@
+# Microsoft.AspNetCore.Http
+
+``` diff
+ namespace Microsoft.AspNetCore.Http {
++    public sealed class AsParametersAttribute : Attribute {
++        public AsParametersAttribute();
++    }
++    public sealed class DefaultRouteHandlerInvocationContext : RouteHandlerInvocationContext {
++        public DefaultRouteHandlerInvocationContext(HttpContext httpContext, params object[] arguments);
++        public override IList<object?> Arguments { get; }
++        public override HttpContext HttpContext { get; }
++        public override T GetArgument<T>(int index);
++    }
+     public static class Results {
+-        public static IResult Content(string content, MediaTypeHeaderValue contentType);
++        public static IResult Content(string? content, MediaTypeHeaderValue contentType);
+-        public static IResult Content(string content, string? contentType = null, Encoding? contentEncoding = null);
++        public static IResult Content(string? content, string? contentType, Encoding? contentEncoding);
++        public static IResult Content(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = default(int?));
+-        public static IResult Text(string content, string? contentType = null, Encoding? contentEncoding = null);
++        public static IResult Text(string? content, string? contentType, Encoding? contentEncoding);
++        public static IResult Text(string? content, string? contentType = null, Encoding? contentEncoding = null, int? statusCode = default(int?));
+     }
+-    public sealed class RouteHandlerInvocationContext {
++    public abstract class RouteHandlerInvocationContext {
++        protected RouteHandlerInvocationContext();
+-        public RouteHandlerInvocationContext(HttpContext httpContext, params object[] parameters);
++        public abstract IList<object?> Arguments { get; }
+-        public HttpContext HttpContext { get; }
++        public abstract HttpContext HttpContext { get; }
+-        public IList<object?> Parameters { get; }
++        public abstract T GetArgument<T>(int index);
+     }
+     public static class TypedResults {
+-        public static Accepted<TValue> Accepted<TValue>(string? uri, TValue? value);
++        public static Accepted<TValue> Accepted<TValue>(string uri, TValue value);
+-        public static AcceptedAtRoute AcceptedAtRoute(string? routeName = null, object? routeValues = null);
++        public static AcceptedAtRoute AcceptedAtRoute(string routeName = null, object routeValues = null);
+-        public static AcceptedAtRoute<TValue> AcceptedAtRoute<TValue>(TValue? value, string? routeName = null, object? routeValues = null);
++        public static AcceptedAtRoute<TValue> AcceptedAtRoute<TValue>(TValue value, string routeName = null, object routeValues = null);
+-        public static BadRequest<TValue> BadRequest<TValue>(TValue? error);
++        public static BadRequest<TValue> BadRequest<TValue>(TValue error);
+-        public static FileContentHttpResult Bytes(byte[] contents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null);
++        public static FileContentHttpResult Bytes(byte[] contents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null);
+-        public static FileContentHttpResult Bytes(ReadOnlyMemory<byte> contents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null);
++        public static FileContentHttpResult Bytes(ReadOnlyMemory<byte> contents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null);
+-        public static Conflict<TValue> Conflict<TValue>(TValue? error);
++        public static Conflict<TValue> Conflict<TValue>(TValue error);
+-        public static ContentHttpResult Content(string content, MediaTypeHeaderValue contentType);
++        public static ContentHttpResult Content(string? content, MediaTypeHeaderValue contentType);
+-        public static ContentHttpResult Content(string content, string? contentType = null, Encoding? contentEncoding = null);
++        public static ContentHttpResult Content(string content, string contentType, Encoding contentEncoding);
++        public static ContentHttpResult Content(string content, string contentType = null, Encoding contentEncoding = null, int? statusCode = default(int?));
+-        public static CreatedAtRoute CreatedAtRoute(string? routeName = null, object? routeValues = null);
++        public static CreatedAtRoute CreatedAtRoute(string routeName = null, object routeValues = null);
+-        public static CreatedAtRoute<TValue> CreatedAtRoute<TValue>(TValue? value, string? routeName = null, object? routeValues = null);
++        public static CreatedAtRoute<TValue> CreatedAtRoute<TValue>(TValue value, string routeName = null, object routeValues = null);
+-        public static FileContentHttpResult File(byte[] fileContents, string? contentType = null, string? fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null);
++        public static FileContentHttpResult File(byte[] fileContents, string contentType = null, string fileDownloadName = null, bool enableRangeProcessing = false, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null);
+-        public static FileStreamHttpResult File(Stream fileStream, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static FileStreamHttpResult File(Stream fileStream, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+-        public static JsonHttpResult<TValue> Json<TValue>(TValue? data, JsonSerializerOptions? options = null, string? contentType = null, int? statusCode = default(int?));
++        public static JsonHttpResult<TValue> Json<TValue>(TValue data, JsonSerializerOptions options = null, string contentType = null, int? statusCode = default(int?));
+-        public static NotFound<TValue> NotFound<TValue>(TValue? value);
++        public static NotFound<TValue> NotFound<TValue>(TValue value);
+-        public static Ok<TValue> Ok<TValue>(TValue? value);
++        public static Ok<TValue> Ok<TValue>(TValue value);
+-        public static PhysicalFileHttpResult PhysicalFile(string path, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static PhysicalFileHttpResult PhysicalFile(string path, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+-        public static ProblemHttpResult Problem(string? detail = null, string? instance = null, int? statusCode = default(int?), string? title = null, string? type = null, IDictionary<string, object?>? extensions = null);
++        public static ProblemHttpResult Problem(string detail = null, string instance = null, int? statusCode = default(int?), string title = null, string type = null, IDictionary<string, object?>? extensions = null);
+-        public static RedirectToRouteHttpResult RedirectToRoute(string? routeName = null, object? routeValues = null, bool permanent = false, bool preserveMethod = false, string? fragment = null);
++        public static RedirectToRouteHttpResult RedirectToRoute(string routeName = null, object routeValues = null, bool permanent = false, bool preserveMethod = false, string fragment = null);
+-        public static PushStreamHttpResult Stream(Func<Stream, Task> streamWriterCallback, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null);
++        public static PushStreamHttpResult Stream(Func<Stream, Task> streamWriterCallback, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null);
+-        public static FileStreamHttpResult Stream(PipeReader pipeReader, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static FileStreamHttpResult Stream(PipeReader pipeReader, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+-        public static FileStreamHttpResult Stream(Stream stream, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static FileStreamHttpResult Stream(Stream stream, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+-        public static ContentHttpResult Text(string content, string? contentType = null, Encoding? contentEncoding = null);
++        public static ContentHttpResult Text(string content, string contentType, Encoding contentEncoding);
++        public static ContentHttpResult Text(string content, string contentType = null, Encoding contentEncoding = null, int? statusCode = default(int?));
+-        public static UnprocessableEntity<TValue> UnprocessableEntity<TValue>(TValue? error);
++        public static UnprocessableEntity<TValue> UnprocessableEntity<TValue>(TValue error);
+-        public static ValidationProblem ValidationProblem(IDictionary<string, string[]> errors, string? detail = null, string? instance = null, string? title = null, string? type = null, IDictionary<string, object?>? extensions = null);
++        public static ValidationProblem ValidationProblem(IDictionary<string, string[]> errors, string detail = null, string instance = null, string title = null, string type = null, IDictionary<string, object?>? extensions = null);
+-        public static VirtualFileHttpResult VirtualFile(string path, string? contentType = null, string? fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue? entityTag = null, bool enableRangeProcessing = false);
++        public static VirtualFileHttpResult VirtualFile(string path, string contentType = null, string fileDownloadName = null, DateTimeOffset? lastModified = default(DateTimeOffset?), EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md
new file mode 100644
index 00000000..d7e1ebbf
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.Mvc.md
@@ -0,0 +1,8 @@
+# Microsoft.AspNetCore.Mvc
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc {
+     public class FromServicesAttribute : Attribute, IBindingSourceMetadata, IFromServiceMetadata
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md
new file mode 100644
index 00000000..1f058d5e
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.ResponseCompression.md
@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.ResponseCompression
+
+``` diff
+ namespace Microsoft.AspNetCore.ResponseCompression {
+     public class CompressionProviderCollection : Collection<ICompressionProvider> {
+-         public void Add(Type providerType);
++         public void Add([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type providerType);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md
new file mode 100644
index 00000000..8f5c5a29
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.SignalR.md
@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.SignalR
+
+``` diff
+ namespace Microsoft.AspNetCore.SignalR {
+     public interface IInvocationBinder {
++        string? GetTarget(ReadOnlySpan<byte> utf8Bytes);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md
new file mode 100644
index 00000000..4c703123
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.AspNetCore.WebUtilities.md
@@ -0,0 +1,14 @@
+# Microsoft.AspNetCore.WebUtilities
+
+``` diff
+ namespace Microsoft.AspNetCore.WebUtilities {
+     public class FormMultipartSection {
++        public ValueTask<string> GetValueAsync(CancellationToken cancellationToken);
+     }
+     public static class MultipartSectionStreamExtensions {
+         public static Task<string> ReadAsStringAsync(this MultipartSection section);
++        public static ValueTask<string> ReadAsStringAsync(this MultipartSection section, CancellationToken cancellationToken);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md
new file mode 100644
index 00000000..21297253
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.Extensions.Logging.md
@@ -0,0 +1,12 @@
+# Microsoft.Extensions.Logging
+
+``` diff
+ namespace Microsoft.Extensions.Logging {
+     public class LoggerFactory : IDisposable, ILoggerFactory {
+-        public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options = null);
++        public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options);
++        public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options = null, IExternalScopeProvider? scopeProvider = null);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md
new file mode 100644
index 00000000..59d2a397
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.AspNetCore.App/7.0-preview5_Microsoft.JSInterop.Infrastructure.md
@@ -0,0 +1,14 @@
+# Microsoft.JSInterop.Infrastructure
+
+``` diff
+ namespace Microsoft.JSInterop.Infrastructure {
+     public static class DotNetDispatcher
+     {
++        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Trimming", "IL2026", Justification = "We expect application code is configured to ensure return types of JSInvokable methods are retained.")]
+         public static string? Invoke(Microsoft.JSInterop.JSRuntime jsRuntime, in Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, string argsJson);
++        [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute("Trimming", "IL2026", Justification = "We expect application code is configured to ensure return types of JSInvokable methods are retained.")]
+         public static void BeginInvokeDotNet(Microsoft.JSInterop.JSRuntime jsRuntime, Microsoft.JSInterop.Infrastructure.DotNetInvocationInfo invocationInfo, string argsJson);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md
new file mode 100644
index 00000000..106f6383
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5.md
@@ -0,0 +1,33 @@
+# API Difference 7.0-preview4 vs 7.0-preview5
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.VisualBasic.FileIO](7.0-preview5_Microsoft.VisualBasic.FileIO.md)
+* [System](7.0-preview5_System.md)
+* [System.Collections.Immutable](7.0-preview5_System.Collections.Immutable.md)
+* [System.ComponentModel](7.0-preview5_System.ComponentModel.md)
+* [System.Data](7.0-preview5_System.Data.md)
+* [System.Diagnostics](7.0-preview5_System.Diagnostics.md)
+* [System.IO](7.0-preview5_System.IO.md)
+* [System.Net](7.0-preview5_System.Net.md)
+* [System.Net.Http](7.0-preview5_System.Net.Http.md)
+* [System.Net.NetworkInformation](7.0-preview5_System.Net.NetworkInformation.md)
+* [System.Net.Security](7.0-preview5_System.Net.Security.md)
+* [System.Net.Sockets](7.0-preview5_System.Net.Sockets.md)
+* [System.Numerics](7.0-preview5_System.Numerics.md)
+* [System.Reflection.Emit](7.0-preview5_System.Reflection.Emit.md)
+* [System.Reflection.Metadata.Ecma335](7.0-preview5_System.Reflection.Metadata.Ecma335.md)
+* [System.Runtime.CompilerServices](7.0-preview5_System.Runtime.CompilerServices.md)
+* [System.Runtime.InteropServices](7.0-preview5_System.Runtime.InteropServices.md)
+* [System.Runtime.InteropServices.Marshalling](7.0-preview5_System.Runtime.InteropServices.Marshalling.md)
+* [System.Runtime.Intrinsics](7.0-preview5_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.X86](7.0-preview5_System.Runtime.Intrinsics.X86.md)
+* [System.Security.Cryptography](7.0-preview5_System.Security.Cryptography.md)
+* [System.Security.Cryptography.X509Certificates](7.0-preview5_System.Security.Cryptography.X509Certificates.md)
+* [System.Text.Json](7.0-preview5_System.Text.Json.md)
+* [System.Text.Json.Nodes](7.0-preview5_System.Text.Json.Nodes.md)
+* [System.Text.Json.Serialization](7.0-preview5_System.Text.Json.Serialization.md)
+* [System.Text.Json.Serialization.Metadata](7.0-preview5_System.Text.Json.Serialization.Metadata.md)
+* [System.Threading](7.0-preview5_System.Threading.md)
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md
new file mode 100644
index 00000000..6481ee6c
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_Microsoft.VisualBasic.FileIO.md
@@ -0,0 +1,10 @@
+# Microsoft.VisualBasic.FileIO
+
+``` diff
+ namespace Microsoft.VisualBasic.FileIO {
+     public class TextFieldParser : IDisposable {
+         public string[]? CommentTokens { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md
new file mode 100644
index 00000000..728b66b0
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Collections.Immutable.md
@@ -0,0 +1,42 @@
+# System.Collections.Immutable
+
+``` diff
+ namespace System.Collections.Immutable {
+     public readonly struct ImmutableArray<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IEquatable<ImmutableArray<T>>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable {
++        public ImmutableArray<T> AddRange(ImmutableArray<T> items, int length);
++        public ImmutableArray<T> AddRange(T[] items, int length);
++        public ImmutableArray<T> AddRange<TDerived>(ImmutableArray<TDerived> items) where TDerived : T;
++        public ImmutableArray<T> AddRange<TDerived>(TDerived[] items) where TDerived : T;
+         public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
++            public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length);
++            public void CopyTo(T[] destination);
++            public int IndexOf(T item, int startIndex, IEqualityComparer<T>? equalityComparer);
++            public void InsertRange(int index, IEnumerable<T> items);
++            public void InsertRange(int index, ImmutableArray<T> items);
++            public bool Remove(T element, IEqualityComparer<T>? equalityComparer);
++            public void RemoveAll(Predicate<T> match);
++            public void RemoveRange(IEnumerable<T> items);
++            public void RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer);
++            public void RemoveRange(int index, int length);
++            public void Replace(T oldValue, T newValue);
++            public void Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer);
+         }
+     }
+     public sealed class ImmutableList<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+         public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
++            public bool Remove(T item, IEqualityComparer<T>? equalityComparer);
++            public void RemoveRange(IEnumerable<T> items);
++            public void RemoveRange(IEnumerable<T> items, IEqualityComparer<T>? equalityComparer);
++            public void RemoveRange(int index, int count);
++            public void Replace(T oldValue, T newValue);
++            public void Replace(T oldValue, T newValue, IEqualityComparer<T>? equalityComparer);
+         }
+     }
+     public sealed class ImmutableSortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IReadOnlySet<T>, ISet<T> {
+         public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
++            public int IndexOf(T item);
+         }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md
new file mode 100644
index 00000000..67b6a2b5
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.ComponentModel.md
@@ -0,0 +1,13 @@
+# System.ComponentModel
+
+``` diff
+ namespace System.ComponentModel {
+     public sealed class TypeDescriptor {
++       [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+         public static Type ComObjectType { get; }
++       [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+         public static Type InterfaceType { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md
new file mode 100644
index 00000000..5a554bc6
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Data.md
@@ -0,0 +1,13 @@
+# System.Data
+
+``` diff
+ namespace System.Data {
+     public class DataColumn : MarshalByValueComponent {
+         public Type DataType { get; set; }
+     }
+     public enum SerializationFormat {
+         Binary = 1,
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md
new file mode 100644
index 00000000..1fefc80e
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Diagnostics.md
@@ -0,0 +1,17 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public readonly struct ActivityEvent {
++        public Activity.Enumerator<KeyValuePair<string, object?>> EnumerateTagObjects();
+     }
+     public readonly struct ActivityLink : IEquatable<ActivityLink> {
++        public Activity.Enumerator<KeyValuePair<string, object?>> EnumerateTagObjects();
+     }
+     public class Process : Component, IDisposable {
+         public TimeSpan PrivilegedProcessorTime { get; }
+         public DateTime StartTime { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md
new file mode 100644
index 00000000..f177f46c
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.IO.md
@@ -0,0 +1,23 @@
+# System.IO
+
+``` diff
+ namespace System.IO {
+     public static class File {
++        public static IAsyncEnumerable<string> ReadLinesAsync(string path, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken));
++        public static IAsyncEnumerable<string> ReadLinesAsync(string path, CancellationToken cancellationToken = default(CancellationToken));
+     }
+     public class FileStream : Stream {
+         public virtual void Lock(long position, long length);
+         public virtual void Unlock(long position, long length);
+     }
+     public abstract class Stream : MarshalByRefObject, IAsyncDisposable, IDisposable {
++        public int ReadAtLeast(Span<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true);
++        public ValueTask<int> ReadAtLeastAsync(Memory<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true, CancellationToken cancellationToken = default(CancellationToken));
++        public void ReadExactly(byte[] buffer, int offset, int count);
++        public void ReadExactly(Span<byte> buffer);
++        public ValueTask ReadExactlyAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken = default(CancellationToken));
++        public ValueTask ReadExactlyAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md
new file mode 100644
index 00000000..8aedea8d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Http.md
@@ -0,0 +1,10 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
+     public class HttpClientHandler : HttpMessageHandler {
+         public IWebProxy Proxy { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md
new file mode 100644
index 00000000..329d97dc
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.NetworkInformation.md
@@ -0,0 +1,21 @@
+# System.Net.NetworkInformation
+
+``` diff
+ namespace System.Net.NetworkInformation {
+     public abstract class IPInterfaceStatistics {
+         public abstract long OutgoingPacketsDiscarded { get; }
+     }
+     public abstract class IPv4InterfaceStatistics {
+         public abstract long OutgoingPacketsDiscarded { get; }
+     }
+     public class NetworkChange {
+         public static event NetworkAddressChangedEventHandler NetworkAddressChanged;
+         public static event NetworkAvailabilityChangedEventHandler NetworkAvailabilityChanged;
+     }
+     public abstract class NetworkInterface {
+         public static int IPv6LoopbackInterfaceIndex { get; }
+         public static int LoopbackInterfaceIndex { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md
new file mode 100644
index 00000000..0e2ee3c9
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Security.md
@@ -0,0 +1,13 @@
+# System.Net.Security
+
+``` diff
+ namespace System.Net.Security {
+     public readonly struct SslClientHelloInfo {
+         public string ServerName { get; }
+         public SslProtocols SslProtocols { get; }
+     }
+-    public sealed class SslStreamCertificateContext
++    public class SslStreamCertificateContext
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md
new file mode 100644
index 00000000..2c06f78f
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.Sockets.md
@@ -0,0 +1,16 @@
+# System.Net.Sockets
+
+``` diff
+ namespace System.Net.Sockets {
+     public sealed class SafeSocketHandle : SafeHandleMinusOneIsInvalid {
++        public override bool IsInvalid { get; }
+     }
+     public sealed class UnixDomainSocketEndPoint : EndPoint {
++        public override AddressFamily AddressFamily { get; }
++        public override EndPoint Create(SocketAddress socketAddress);
++        public override SocketAddress Serialize();
++        public override string ToString();
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md
new file mode 100644
index 00000000..e0466298
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Net.md
@@ -0,0 +1,10 @@
+# System.Net
+
+``` diff
+ namespace System.Net {
+     public class IPAddress {
+         public long Address { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md
new file mode 100644
index 00000000..1ef7bf18
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Numerics.md
@@ -0,0 +1,239 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+-    public readonly struct BigInteger : IComparable, IComparable<BigInteger>, IEquatable<BigInteger>, IFormattable, ISpanFormattable {
++    public readonly struct BigInteger : IAdditionOperators<BigInteger, BigInteger, BigInteger>, IAdditiveIdentity<BigInteger, BigInteger>, IBinaryInteger<BigInteger>, IBinaryNumber<BigInteger>, IBitwiseOperators<BigInteger, BigInteger, BigInteger>, IComparable, IComparable<BigInteger>, IComparisonOperators<BigInteger, BigInteger>, IDecrementOperators<BigInteger>, IDivisionOperators<BigInteger, BigInteger, BigInteger>, IEqualityOperators<BigInteger, BigInteger>, IEquatable<BigInteger>, IFormattable, IIncrementOperators<BigInteger>, IModulusOperators<BigInteger, BigInteger, BigInteger>, IMultiplicativeIdentity<BigInteger, BigInteger>, IMultiplyOperators<BigInteger, BigInteger, BigInteger>, INumber<BigInteger>, INumberBase<BigInteger>, IParsable<BigInteger>, IShiftOperators<BigInteger, BigInteger>, ISignedNumber<BigInteger>, ISpanFormattable, ISpanParsable<BigInteger>, ISubtractionOperators<BigInteger, BigInteger, BigInteger>, IUnaryNegationOperators<BigInteger, BigInteger>, IUnaryPlusOperators<BigInteger, BigInteger> {
++        static BigInteger System.Numerics.IAdditiveIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>.AdditiveIdentity { get; }
++        static BigInteger System.Numerics.IMultiplicativeIdentity<System.Numerics.BigInteger,System.Numerics.BigInteger>.MultiplicativeIdentity { get; }
++        static int System.Numerics.INumberBase<System.Numerics.BigInteger>.Radix { get; }
++        static BigInteger System.Numerics.ISignedNumber<System.Numerics.BigInteger>.NegativeOne { get; }
++        public static BigInteger Clamp(BigInteger value, BigInteger min, BigInteger max);
++        public static BigInteger CopySign(BigInteger value, BigInteger sign);
++        public static (BigInteger Quotient, BigInteger Remainder) DivRem(BigInteger left, BigInteger right);
++        public static bool IsEvenInteger(BigInteger value);
++        public static bool IsNegative(BigInteger value);
++        public static bool IsOddInteger(BigInteger value);
++        public static bool IsPositive(BigInteger value);
++        public static bool IsPow2(BigInteger value);
++        public static BigInteger LeadingZeroCount(BigInteger value);
++        public static BigInteger Log2(BigInteger value);
++        public static BigInteger MaxMagnitude(BigInteger x, BigInteger y);
++        public static BigInteger MinMagnitude(BigInteger x, BigInteger y);
++        public static explicit operator BigInteger (Half value);
++        public static explicit operator char (BigInteger value);
++        public static explicit operator Half (BigInteger value);
++        public static explicit operator Int128 (BigInteger value);
++        public static explicit operator nint (BigInteger value);
++        public static explicit operator UInt128 (BigInteger value);
++        public static explicit operator nuint (BigInteger value);
++        public static explicit operator BigInteger (Complex value);
++        public static implicit operator BigInteger (char value);
++        public static implicit operator BigInteger (Int128 value);
++        public static implicit operator BigInteger (IntPtr value);
++        public static implicit operator BigInteger (UInt128 value);
++        public static implicit operator BigInteger (UIntPtr value);
++        public static BigInteger operator >>>(BigInteger value, int shiftAmount);
++        public static BigInteger Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
++        public static BigInteger PopCount(BigInteger value);
++        public static BigInteger RotateLeft(BigInteger value, int rotateAmount);
++        public static BigInteger RotateRight(BigInteger value, int rotateAmount);
++        static BigInteger IAdditionOperators<BigInteger, BigInteger, BigInteger>.operator checked +(BigInteger left, BigInteger right);
++        int IBinaryInteger<BigInteger>.GetByteCount();
++        int IBinaryInteger<BigInteger>.GetShortestBitLength();
++        bool IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten);
++        static BigInteger IDecrementOperators<BigInteger>.operator checked --(BigInteger value);
++        static BigInteger IDivisionOperators<BigInteger, BigInteger, BigInteger>.operator checked /(BigInteger left, BigInteger right);
++        static BigInteger IIncrementOperators<BigInteger>.operator checked ++(BigInteger value);
++        static BigInteger IMultiplyOperators<BigInteger, BigInteger, BigInteger>.operator checked *(BigInteger left, BigInteger right);
++        static BigInteger INumber<BigInteger>.MaxNumber(BigInteger x, BigInteger y);
++        static BigInteger INumber<BigInteger>.MinNumber(BigInteger x, BigInteger y);
++        static int INumber<BigInteger>.Sign(BigInteger value);
++        static bool INumberBase<BigInteger>.IsCanonical(BigInteger value);
++        static bool INumberBase<BigInteger>.IsComplexNumber(BigInteger value);
++        static bool INumberBase<BigInteger>.IsFinite(BigInteger value);
++        static bool INumberBase<BigInteger>.IsImaginaryNumber(BigInteger value);
++        static bool INumberBase<BigInteger>.IsInfinity(BigInteger value);
++        static bool INumberBase<BigInteger>.IsInteger(BigInteger value);
++        static bool INumberBase<BigInteger>.IsNaN(BigInteger value);
++        static bool INumberBase<BigInteger>.IsNegativeInfinity(BigInteger value);
++        static bool INumberBase<BigInteger>.IsNormal(BigInteger value);
++        static bool INumberBase<BigInteger>.IsPositiveInfinity(BigInteger value);
++        static bool INumberBase<BigInteger>.IsRealNumber(BigInteger value);
++        static bool INumberBase<BigInteger>.IsSubnormal(BigInteger value);
++        static bool INumberBase<BigInteger>.IsZero(BigInteger value);
++        static BigInteger INumberBase<BigInteger>.MaxMagnitudeNumber(BigInteger x, BigInteger y);
++        static BigInteger INumberBase<BigInteger>.MinMagnitudeNumber(BigInteger x, BigInteger y);
++        static bool INumberBase<BigInteger>.TryConvertFromChecked<TOther>(TOther value, out BigInteger result);
++        static bool INumberBase<BigInteger>.TryConvertFromSaturating<TOther>(TOther value, out BigInteger result);
++        static bool INumberBase<BigInteger>.TryConvertFromTruncating<TOther>(TOther value, out BigInteger result);
++        static bool INumberBase<BigInteger>.TryConvertToChecked<TOther>(BigInteger value, out TOther result);
++        static bool INumberBase<BigInteger>.TryConvertToSaturating<TOther>(BigInteger value, out TOther result);
++        static bool INumberBase<BigInteger>.TryConvertToTruncating<TOther>(BigInteger value, out TOther result);
++        static BigInteger ISubtractionOperators<BigInteger, BigInteger, BigInteger>.operator checked -(BigInteger left, BigInteger right);
++        static BigInteger IUnaryNegationOperators<BigInteger, BigInteger>.operator checked -(BigInteger value);
++        public static BigInteger TrailingZeroCount(BigInteger value);
++        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out BigInteger result);
++        public static bool TryParse(string? s, IFormatProvider? provider, out BigInteger result);
+     }
+-    public readonly struct Complex : IEquatable<Complex>, IFormattable {
++    public readonly struct Complex : IAdditionOperators<Complex, Complex, Complex>, IAdditiveIdentity<Complex, Complex>, IDecrementOperators<Complex>, IDivisionOperators<Complex, Complex, Complex>, IEqualityOperators<Complex, Complex>, IEquatable<Complex>, IFormattable, IIncrementOperators<Complex>, IMultiplicativeIdentity<Complex, Complex>, IMultiplyOperators<Complex, Complex, Complex>, INumberBase<Complex>, IParsable<Complex>, ISignedNumber<Complex>, ISpanFormattable, ISpanParsable<Complex>, ISubtractionOperators<Complex, Complex, Complex>, IUnaryNegationOperators<Complex, Complex>, IUnaryPlusOperators<Complex, Complex> {
++        static Complex System.Numerics.IAdditiveIdentity<System.Numerics.Complex,System.Numerics.Complex>.AdditiveIdentity { get; }
++        static Complex System.Numerics.IMultiplicativeIdentity<System.Numerics.Complex,System.Numerics.Complex>.MultiplicativeIdentity { get; }
++        static Complex System.Numerics.INumberBase<System.Numerics.Complex>.One { get; }
++        static int System.Numerics.INumberBase<System.Numerics.Complex>.Radix { get; }
++        static Complex System.Numerics.INumberBase<System.Numerics.Complex>.Zero { get; }
++        static Complex System.Numerics.ISignedNumber<System.Numerics.Complex>.NegativeOne { get; }
++        public static bool IsComplexNumber(Complex value);
++        public static bool IsEvenInteger(Complex value);
++        public static bool IsImaginaryNumber(Complex value);
++        public static bool IsInteger(Complex value);
++        public static bool IsNegative(Complex value);
++        public static bool IsNegativeInfinity(Complex value);
++        public static bool IsNormal(Complex value);
++        public static bool IsOddInteger(Complex value);
++        public static bool IsPositive(Complex value);
++        public static bool IsPositiveInfinity(Complex value);
++        public static bool IsRealNumber(Complex value);
++        public static bool IsSubnormal(Complex value);
++        public static Complex MaxMagnitude(Complex x, Complex y);
++        public static Complex MinMagnitude(Complex x, Complex y);
++        public static Complex operator --(Complex value);
++        public static explicit operator Complex (Int128 value);
++        public static explicit operator Complex (UInt128 value);
++        public static implicit operator Complex (char value);
++        public static implicit operator Complex (Half value);
++        public static implicit operator Complex (IntPtr value);
++        public static implicit operator Complex (UIntPtr value);
++        public static Complex operator ++(Complex value);
++        public static Complex operator +(Complex value);
++        public static Complex Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
++        public static Complex Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
++        public static Complex Parse(string s, NumberStyles style, IFormatProvider? provider);
++        public static Complex Parse(string s, IFormatProvider? provider);
++        static Complex IAdditionOperators<Complex, Complex, Complex>.operator checked +(Complex left, Complex right);
++        static Complex IDecrementOperators<Complex>.operator checked --(Complex value);
++        static Complex IDivisionOperators<Complex, Complex, Complex>.operator checked /(Complex left, Complex right);
++        static Complex IIncrementOperators<Complex>.operator checked ++(Complex value);
++        static Complex IMultiplyOperators<Complex, Complex, Complex>.operator checked *(Complex left, Complex right);
++        static Complex INumberBase<Complex>.Abs(Complex value);
++        static bool INumberBase<Complex>.IsCanonical(Complex value);
++        static bool INumberBase<Complex>.IsZero(Complex value);
++        static Complex INumberBase<Complex>.MaxMagnitudeNumber(Complex x, Complex y);
++        static Complex INumberBase<Complex>.MinMagnitudeNumber(Complex x, Complex y);
++        static bool INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther value, out Complex result);
++        static bool INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther value, out Complex result);
++        static bool INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther value, out Complex result);
++        static bool INumberBase<Complex>.TryConvertToChecked<TOther>(Complex value, out TOther result);
++        static bool INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex value, out TOther result);
++        static bool INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex value, out TOther result);
++        static Complex ISubtractionOperators<Complex, Complex, Complex>.operator checked -(Complex left, Complex right);
++        static Complex IUnaryNegationOperators<Complex, Complex>.operator checked -(Complex value);
++        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider);
++        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out Complex result);
++        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out Complex result);
++        public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Complex result);
++        public static bool TryParse(string? s, IFormatProvider? provider, out Complex result);
+     }
+     public interface IBinaryInteger<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IBinaryNumber<TSelf>, IBitwiseOperators<TSelf, TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, IShiftOperators<TSelf, TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IBinaryInteger<TSelf> {
+-        long GetShortestBitLength();
++        int GetShortestBitLength();
++        bool TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        int WriteBigEndian(byte[] destination);
++        int WriteBigEndian(byte[] destination, int startIndex);
++        int WriteBigEndian(Span<byte> destination);
+     }
+     public interface IExponentialFunctions<TSelf> where TSelf : IExponentialFunctions<TSelf> {
++        static abstract TSelf Exp10(TSelf x);
++        static abstract TSelf Exp10M1(TSelf x);
++        static abstract TSelf Exp2(TSelf x);
++        static abstract TSelf Exp2M1(TSelf x);
++        static abstract TSelf ExpM1(TSelf x);
+     }
+     public interface IFloatingPoint<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, ISignedNumber<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IFloatingPoint<TSelf> {
+-        long GetExponentShortestBitLength();
++        int GetExponentShortestBitLength();
+-        long GetSignificandBitLength();
++        int GetSignificandBitLength();
++        bool TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        int WriteExponentBigEndian(byte[] destination);
++        int WriteExponentBigEndian(byte[] destination, int startIndex);
++        int WriteExponentBigEndian(Span<byte> destination);
++        int WriteSignificandBigEndian(byte[] destination);
++        int WriteSignificandBigEndian(byte[] destination, int startIndex);
++        int WriteSignificandBigEndian(Span<byte> destination);
+     }
+     public interface IFloatingPointIeee754<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IExponentialFunctions<TSelf>, IFloatingPoint<TSelf>, IFormattable, IHyperbolicFunctions<TSelf>, IIncrementOperators<TSelf>, ILogarithmicFunctions<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, INumberBase<TSelf>, IParsable<TSelf>, IPowerFunctions<TSelf>, IRootFunctions<TSelf>, ISignedNumber<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, ITrigonometricFunctions<TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IFloatingPointIeee754<TSelf> {
+-        static abstract bool IsFinite(TSelf value);
+-        static abstract bool IsInfinity(TSelf value);
+-        static abstract bool IsNaN(TSelf value);
+-        static abstract bool IsNegativeInfinity(TSelf value);
+-        static abstract bool IsNormal(TSelf value);
+-        static abstract bool IsPositiveInfinity(TSelf value);
+-        static abstract bool IsSubnormal(TSelf value);
+     }
+     public interface ILogarithmicFunctions<TSelf> where TSelf : ILogarithmicFunctions<TSelf> {
++        static abstract TSelf Log10P1(TSelf x);
++        static abstract TSelf Log2P1(TSelf x);
++        static abstract TSelf LogP1(TSelf x);
+     }
+     public interface INumber<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparable, IComparable<TSelf>, IComparisonOperators<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, INumberBase<TSelf>, IParsable<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumber<TSelf> {
+-        static abstract TSelf Abs(TSelf value);
+-        static abstract TSelf CreateChecked<TOther>(TOther value);
+-        static abstract TSelf CreateSaturating<TOther>(TOther value);
+-        static abstract TSelf CreateTruncating<TOther>(TOther value);
+-        static abstract bool IsNegative(TSelf value);
+-        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
++        static abstract TSelf MaxNumber(TSelf x, TSelf y);
+-        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
++        static abstract TSelf MinNumber(TSelf x, TSelf y);
+-        static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
+-        static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider);
+-        static abstract bool TryCreate<TOther>(TOther value, out TSelf result);
+-        static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result);
+-        static abstract bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out TSelf result);
+     }
+-    public interface INumberBase<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumberBase<TSelf> {
++    public interface INumberBase<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IFormattable, IIncrementOperators<TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, IParsable<TSelf>, ISpanFormattable, ISpanParsable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumberBase<TSelf> {
++        static abstract int Radix { get; }
++        static abstract TSelf Abs(TSelf value);
++        static TSelf CreateChecked<TOther>(TOther value);
++        static TSelf CreateSaturating<TOther>(TOther value);
++        static TSelf CreateTruncating<TOther>(TOther value);
++        static abstract bool IsCanonical(TSelf value);
++        static abstract bool IsComplexNumber(TSelf value);
++        static abstract bool IsEvenInteger(TSelf value);
++        static abstract bool IsFinite(TSelf value);
++        static abstract bool IsImaginaryNumber(TSelf value);
++        static abstract bool IsInfinity(TSelf value);
++        static abstract bool IsInteger(TSelf value);
++        static abstract bool IsNaN(TSelf value);
++        static abstract bool IsNegative(TSelf value);
++        static abstract bool IsNegativeInfinity(TSelf value);
++        static abstract bool IsNormal(TSelf value);
++        static abstract bool IsOddInteger(TSelf value);
++        static abstract bool IsPositive(TSelf value);
++        static abstract bool IsPositiveInfinity(TSelf value);
++        static abstract bool IsRealNumber(TSelf value);
++        static abstract bool IsSubnormal(TSelf value);
++        static abstract bool IsZero(TSelf value);
++        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
++        static abstract TSelf MaxMagnitudeNumber(TSelf x, TSelf y);
++        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
++        static abstract TSelf MinMagnitudeNumber(TSelf x, TSelf y);
++        static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
++        static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider);
++        static abstract bool TryConvertFromChecked<TOther>(TOther value, out TSelf? result);
++        static abstract bool TryConvertFromSaturating<TOther>(TOther value, out TSelf? result);
++        static abstract bool TryConvertFromTruncating<TOther>(TOther value, out TSelf? result);
++        static abstract bool TryConvertToChecked<TOther>(TSelf value, out TOther? result);
++        static abstract bool TryConvertToSaturating<TOther>(TSelf value, out TOther? result);
++        static abstract bool TryConvertToTruncating<TOther>(TSelf value, out TOther? result);
++        static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result);
++        static abstract bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out TSelf result);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md
new file mode 100644
index 00000000..7ae5d108
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Emit.md
@@ -0,0 +1,14 @@
+# System.Reflection.Emit
+
+``` diff
+ namespace System.Reflection.Emit {
+     public sealed class AssemblyBuilder : Assembly {
+         public override string? CodeBase { get; }
+     }
+     public class ModuleBuilder : Module {
+         public override string FullyQualifiedName { get; }
+         public override string Name { get; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md
new file mode 100644
index 00000000..12659e0c
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Reflection.Metadata.Ecma335.md
@@ -0,0 +1,17 @@
+# System.Reflection.Metadata.Ecma335
+
+``` diff
+ namespace System.Reflection.Metadata.Ecma335 {
+     public readonly struct BlobEncoder {
++        public FieldTypeEncoder Field();
+     }
++    public readonly struct FieldTypeEncoder {
++        public FieldTypeEncoder(BlobBuilder builder);
++        public BlobBuilder Builder { get; }
++        public CustomModifiersEncoder CustomModifiers();
++        public SignatureTypeEncoder Type(bool isByRef = false);
++        public void TypedReference();
++    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md
new file mode 100644
index 00000000..b0524c1f
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.CompilerServices.md
@@ -0,0 +1,10 @@
+# System.Runtime.CompilerServices
+
+``` diff
+ namespace System.Runtime.CompilerServices {
+     public static class RuntimeFeature {
++        public const string NumericIntPtr = "NumericIntPtr";
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md
new file mode 100644
index 00000000..49642ce1
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.Marshalling.md
@@ -0,0 +1,104 @@
+# System.Runtime.InteropServices.Marshalling
+
+``` diff
++namespace System.Runtime.InteropServices.Marshalling {
++    public ref struct AnsiStringMarshaller {
++        public AnsiStringMarshaller(string? str);
++        public AnsiStringMarshaller(string? str, Span<byte> buffer);
++        public void FreeNative();
++        public unsafe void FromNativeValue(byte* value);
++        public string? ToManaged();
++        public unsafe byte* ToNativeValue();
++    }
++    public ref struct ArrayMarshaller<T> {
++        public ArrayMarshaller(int sizeOfNativeElement);
++        public ArrayMarshaller(T[]? array, int sizeOfNativeElement);
++        public ArrayMarshaller(T[]? array, Span<byte> buffer, int sizeOfNativeElement);
++        public void FreeNative();
++        public unsafe void FromNativeValue(byte* value);
++        public Span<T> GetManagedValuesDestination(int length);
++        public ReadOnlySpan<T> GetManagedValuesSource();
++        public Span<byte> GetNativeValuesDestination();
++        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
++        public ref byte GetPinnableReference();
++        public T[]? ToManaged();
++        public unsafe byte* ToNativeValue();
++    }
++    public ref struct BStrStringMarshaller {
++        public BStrStringMarshaller(string? str);
++        public BStrStringMarshaller(string? str, Span<ushort> buffer);
++        public void FreeNative();
++        public unsafe void FromNativeValue(void* value);
++        public string? ToManaged();
++        public unsafe void* ToNativeValue();
++    }
++    public sealed class CustomTypeMarshallerAttribute : Attribute {
++        public CustomTypeMarshallerAttribute(Type managedType, CustomTypeMarshallerKind marshallerKind = CustomTypeMarshallerKind.Value);
++        public int BufferSize { get; set; }
++        public CustomTypeMarshallerDirection Direction { get; set; }
++        public CustomTypeMarshallerFeatures Features { get; set; }
++        public Type ManagedType { get; }
++        public CustomTypeMarshallerKind MarshallerKind { get; }
++        public struct GenericPlaceholder
++    }
++    public enum CustomTypeMarshallerDirection {
++        In = 1,
++        None = 0,
++        Out = 2,
++        Ref = 3,
++    }
++    public enum CustomTypeMarshallerFeatures {
++        CallerAllocatedBuffer = 2,
++        None = 0,
++        TwoStageMarshalling = 4,
++        UnmanagedResources = 1,
++    }
++    public enum CustomTypeMarshallerKind {
++        LinearCollection = 1,
++        Value = 0,
++    }
++    public sealed class MarshalUsingAttribute : Attribute {
++        public const string ReturnsCountValue = "return-value";
++        public MarshalUsingAttribute();
++        public MarshalUsingAttribute(Type nativeType);
++        public int ConstantElementCount { get; set; }
++        public string CountElementName { get; set; }
++        public int ElementIndirectionDepth { get; set; }
++        public Type? NativeType { get; }
++    }
++    public sealed class NativeMarshallingAttribute : Attribute {
++        public NativeMarshallingAttribute(Type nativeType);
++        public Type NativeType { get; }
++    }
++    public ref struct PointerArrayMarshaller<T> where T : struct {
++        public PointerArrayMarshaller(int sizeOfNativeElement);
++        public PointerArrayMarshaller(T*[]? array, int sizeOfNativeElement);
++        public PointerArrayMarshaller(T*[]? array, Span<byte> buffer, int sizeOfNativeElement);
++        public void FreeNative();
++        public unsafe void FromNativeValue(byte* value);
++        public Span<IntPtr> GetManagedValuesDestination(int length);
++        public ReadOnlySpan<IntPtr> GetManagedValuesSource();
++        public Span<byte> GetNativeValuesDestination();
++        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
++        public ref byte GetPinnableReference();
++        public T*[]? ToManaged();
++        public unsafe byte* ToNativeValue();
++    }
++    public ref struct Utf16StringMarshaller {
++        public Utf16StringMarshaller(string? str);
++        public void FreeNative();
++        public unsafe void FromNativeValue(void* value);
++        public string? ToManaged();
++        public unsafe void* ToNativeValue();
++    }
++    public ref struct Utf8StringMarshaller {
++        public Utf8StringMarshaller(string? str);
++        public Utf8StringMarshaller(string? str, Span<byte> buffer);
++        public void FreeNative();
++        public unsafe void FromNativeValue(byte* value);
++        public string? ToManaged();
++        public unsafe byte* ToNativeValue();
++    }
++}
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md
new file mode 100644
index 00000000..203cb608
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.InteropServices.md
@@ -0,0 +1,160 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
+-    public ref struct AnsiStringMarshaller {
+-        public AnsiStringMarshaller(string? str);
+-        public AnsiStringMarshaller(string? str, Span<byte> buffer);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(byte* value);
+-        public string? ToManaged();
+-        public unsafe byte* ToNativeValue();
+-    }
+-    public ref struct ArrayMarshaller<T> {
+-        public ArrayMarshaller(int sizeOfNativeElement);
+-        public ArrayMarshaller(T[]? array, int sizeOfNativeElement);
+-        public ArrayMarshaller(T[]? array, Span<byte> buffer, int sizeOfNativeElement);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(byte* value);
+-        public Span<T> GetManagedValuesDestination(int length);
+-        public ReadOnlySpan<T> GetManagedValuesSource();
+-        public Span<byte> GetNativeValuesDestination();
+-        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
+-        public ref byte GetPinnableReference();
+-        public T[]? ToManaged();
+-        public unsafe byte* ToNativeValue();
+-    }
+-    public sealed class CustomTypeMarshallerAttribute : Attribute {
+-        public CustomTypeMarshallerAttribute(Type managedType, CustomTypeMarshallerKind marshallerKind = CustomTypeMarshallerKind.Value);
+-        public int BufferSize { get; set; }
+-        public CustomTypeMarshallerDirection Direction { get; set; }
+-        public CustomTypeMarshallerFeatures Features { get; set; }
+-        public Type ManagedType { get; }
+-        public CustomTypeMarshallerKind MarshallerKind { get; }
+-        public struct GenericPlaceholder
+-    }
+-    public enum CustomTypeMarshallerDirection {
+-        In = 1,
+-        None = 0,
+-        Out = 2,
+-        Ref = 3,
+-    }
+-    public enum CustomTypeMarshallerFeatures {
+-        CallerAllocatedBuffer = 2,
+-        None = 0,
+-        TwoStageMarshalling = 4,
+-        UnmanagedResources = 1,
+-    }
+-    public enum CustomTypeMarshallerKind {
+-        LinearCollection = 1,
+-        Value = 0,
+-    }
+-    public sealed class MarshalUsingAttribute : Attribute {
+-        public const string ReturnsCountValue = "return-value";
+-        public MarshalUsingAttribute();
+-        public MarshalUsingAttribute(Type nativeType);
+-        public int ConstantElementCount { get; set; }
+-        public string CountElementName { get; set; }
+-        public int ElementIndirectionDepth { get; set; }
+-        public Type? NativeType { get; }
+-    }
+-    public sealed class NativeMarshallingAttribute : Attribute {
+-        public NativeMarshallingAttribute(Type nativeType);
+-        public Type NativeType { get; }
+-    }
+     public static class NativeMemory {
++        public unsafe static void ZeroMemory(void* ptr, UIntPtr byteCount);
+     }
+     public readonly struct NFloat : IAdditionOperators<NFloat, NFloat, NFloat>, IAdditiveIdentity<NFloat, NFloat>, IBinaryFloatingPointIeee754<NFloat>, IBinaryNumber<NFloat>, IBitwiseOperators<NFloat, NFloat, NFloat>, IComparable, IComparable<NFloat>, IComparisonOperators<NFloat, NFloat>, IDecrementOperators<NFloat>, IDivisionOperators<NFloat, NFloat, NFloat>, IEqualityOperators<NFloat, NFloat>, IEquatable<NFloat>, IExponentialFunctions<NFloat>, IFloatingPoint<NFloat>, IFloatingPointIeee754<NFloat>, IFormattable, IHyperbolicFunctions<NFloat>, IIncrementOperators<NFloat>, ILogarithmicFunctions<NFloat>, IMinMaxValue<NFloat>, IModulusOperators<NFloat, NFloat, NFloat>, IMultiplicativeIdentity<NFloat, NFloat>, IMultiplyOperators<NFloat, NFloat, NFloat>, INumber<NFloat>, INumberBase<NFloat>, IParsable<NFloat>, IPowerFunctions<NFloat>, IRootFunctions<NFloat>, ISignedNumber<NFloat>, ISpanFormattable, ISpanParsable<NFloat>, ISubtractionOperators<NFloat, NFloat, NFloat>, ITrigonometricFunctions<NFloat>, IUnaryNegationOperators<NFloat, NFloat>, IUnaryPlusOperators<NFloat, NFloat> {
++        static int System.Numerics.INumberBase<System.Runtime.InteropServices.NFloat>.Radix { get; }
+-        public static NFloat CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static NFloat CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static NFloat CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static NFloat Exp10(NFloat x);
++        public static NFloat Exp10M1(NFloat x);
++        public static NFloat Exp2(NFloat x);
++        public static NFloat Exp2M1(NFloat x);
++        public static NFloat ExpM1(NFloat x);
++        public static bool IsEvenInteger(NFloat value);
++        public static bool IsInteger(NFloat value);
++        public static bool IsOddInteger(NFloat value);
++        public static bool IsPositive(NFloat value);
++        public static bool IsRealNumber(NFloat value);
++        public static NFloat Log10P1(NFloat x);
++        public static NFloat Log2P1(NFloat x);
++        public static NFloat LogP1(NFloat x);
++        public static NFloat MaxMagnitudeNumber(NFloat x, NFloat y);
++        public static NFloat MaxNumber(NFloat x, NFloat y);
++        public static NFloat MinMagnitudeNumber(NFloat x, NFloat y);
++        public static NFloat MinNumber(NFloat x, NFloat y);
++        public static explicit operator checked byte (NFloat value);
++        public static explicit operator checked char (NFloat value);
++        public static explicit operator checked short (NFloat value);
++        public static explicit operator checked int (NFloat value);
++        public static explicit operator checked long (NFloat value);
++        public static explicit operator checked Int128 (NFloat value);
++        public static explicit operator checked IntPtr (NFloat value);
++        public static explicit operator checked sbyte (NFloat value);
++        public static explicit operator checked ushort (NFloat value);
++        public static explicit operator checked uint (NFloat value);
++        public static explicit operator checked ulong (NFloat value);
++        public static explicit operator checked UInt128 (NFloat value);
++        public static explicit operator checked UIntPtr (NFloat value);
++        public static explicit operator NFloat (Int128 value);
++        public static explicit operator Half (NFloat value);
++        public static explicit operator Int128 (NFloat value);
++        public static explicit operator UInt128 (NFloat value);
++        public static explicit operator NFloat (UInt128 value);
++        public static implicit operator NFloat (Half value);
+-        long IFloatingPoint<NFloat>.GetExponentShortestBitLength();
++        int IFloatingPoint<NFloat>.GetExponentShortestBitLength();
+-        long IFloatingPoint<NFloat>.GetSignificandBitLength();
++        int IFloatingPoint<NFloat>.GetSignificandBitLength();
++        bool IFloatingPoint<NFloat>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<NFloat>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool INumberBase<NFloat>.IsCanonical(NFloat value);
++        static bool INumberBase<NFloat>.IsComplexNumber(NFloat value);
++        static bool INumberBase<NFloat>.IsImaginaryNumber(NFloat value);
++        static bool INumberBase<NFloat>.IsZero(NFloat value);
++        static bool INumberBase<NFloat>.TryConvertFromChecked<TOther>(TOther value, out NFloat result);
++        static bool INumberBase<NFloat>.TryConvertFromSaturating<TOther>(TOther value, out NFloat result);
++        static bool INumberBase<NFloat>.TryConvertFromTruncating<TOther>(TOther value, out NFloat result);
++        static bool INumberBase<NFloat>.TryConvertToChecked<TOther>(NFloat value, out TOther result);
++        static bool INumberBase<NFloat>.TryConvertToSaturating<TOther>(NFloat value, out TOther result);
++        static bool INumberBase<NFloat>.TryConvertToTruncating<TOther>(NFloat value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out NFloat result) where TOther : INumber<TOther>;
+     }
+-    public ref struct PointerArrayMarshaller<T> where T : struct {
+-        public PointerArrayMarshaller(int sizeOfNativeElement);
+-        public PointerArrayMarshaller(T*[]? array, int sizeOfNativeElement);
+-        public PointerArrayMarshaller(T*[]? array, Span<byte> buffer, int sizeOfNativeElement);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(byte* value);
+-        public Span<IntPtr> GetManagedValuesDestination(int length);
+-        public ReadOnlySpan<IntPtr> GetManagedValuesSource();
+-        public Span<byte> GetNativeValuesDestination();
+-        public ReadOnlySpan<byte> GetNativeValuesSource(int length);
+-        public ref byte GetPinnableReference();
+-        public T*[]? ToManaged();
+-        public unsafe byte* ToNativeValue();
+-    }
+-    public ref struct Utf16StringMarshaller {
+-        public Utf16StringMarshaller(string? str);
+-        public Utf16StringMarshaller(string? str, Span<ushort> buffer);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(ushort* value);
+-        public ref ushort GetPinnableReference();
+-        public string? ToManaged();
+-        public unsafe ushort* ToNativeValue();
+-    }
+-    public ref struct Utf8StringMarshaller {
+-        public Utf8StringMarshaller(string? str);
+-        public Utf8StringMarshaller(string? str, Span<byte> buffer);
+-        public void FreeNative();
+-        public unsafe void FromNativeValue(byte* value);
+-        public string? ToManaged();
+-        public unsafe byte* ToNativeValue();
+-    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md
new file mode 100644
index 00000000..23a3cf0d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.X86.md
@@ -0,0 +1,14 @@
+# System.Runtime.Intrinsics.X86
+
+``` diff
+ namespace System.Runtime.Intrinsics.X86 {
++    public abstract class X86Serialize : X86Base {
++        public static new bool IsSupported { get; }
++        public static void Serialize();
++        public new abstract class X64 : X86Base.X64 {
++            public static new bool IsSupported { get; }
++        }
++    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md
new file mode 100644
index 00000000..33b6ee81
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Runtime.Intrinsics.md
@@ -0,0 +1,40 @@
+# System.Runtime.Intrinsics
+
+``` diff
+ namespace System.Runtime.Intrinsics {
+     public static class Vector128 {
++        public static Vector128<byte> Shuffle(Vector128<byte> vector, Vector128<byte> indices);
++        public static Vector128<double> Shuffle(Vector128<double> vector, Vector128<long> indices);
++        public static Vector128<short> Shuffle(Vector128<short> vector, Vector128<short> indices);
++        public static Vector128<int> Shuffle(Vector128<int> vector, Vector128<int> indices);
++        public static Vector128<long> Shuffle(Vector128<long> vector, Vector128<long> indices);
++        public static Vector128<sbyte> Shuffle(Vector128<sbyte> vector, Vector128<sbyte> indices);
++        public static Vector128<float> Shuffle(Vector128<float> vector, Vector128<int> indices);
++        public static Vector128<ushort> Shuffle(Vector128<ushort> vector, Vector128<ushort> indices);
++        public static Vector128<uint> Shuffle(Vector128<uint> vector, Vector128<uint> indices);
++        public static Vector128<ulong> Shuffle(Vector128<ulong> vector, Vector128<ulong> indices);
+     }
+     public static class Vector256 {
++        public static Vector256<byte> Shuffle(Vector256<byte> vector, Vector256<byte> indices);
++        public static Vector256<double> Shuffle(Vector256<double> vector, Vector256<long> indices);
++        public static Vector256<short> Shuffle(Vector256<short> vector, Vector256<short> indices);
++        public static Vector256<int> Shuffle(Vector256<int> vector, Vector256<int> indices);
++        public static Vector256<long> Shuffle(Vector256<long> vector, Vector256<long> indices);
++        public static Vector256<sbyte> Shuffle(Vector256<sbyte> vector, Vector256<sbyte> indices);
++        public static Vector256<float> Shuffle(Vector256<float> vector, Vector256<int> indices);
++        public static Vector256<ushort> Shuffle(Vector256<ushort> vector, Vector256<ushort> indices);
++        public static Vector256<uint> Shuffle(Vector256<uint> vector, Vector256<uint> indices);
++        public static Vector256<ulong> Shuffle(Vector256<ulong> vector, Vector256<ulong> indices);
+     }
+     public static class Vector64 {
++        public static Vector64<byte> Shuffle(Vector64<byte> vector, Vector64<byte> indices);
++        public static Vector64<short> Shuffle(Vector64<short> vector, Vector64<short> indices);
++        public static Vector64<int> Shuffle(Vector64<int> vector, Vector64<int> indices);
++        public static Vector64<sbyte> Shuffle(Vector64<sbyte> vector, Vector64<sbyte> indices);
++        public static Vector64<float> Shuffle(Vector64<float> vector, Vector64<int> indices);
++        public static Vector64<ushort> Shuffle(Vector64<ushort> vector, Vector64<ushort> indices);
++        public static Vector64<uint> Shuffle(Vector64<uint> vector, Vector64<uint> indices);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md
new file mode 100644
index 00000000..568c1008
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.X509Certificates.md
@@ -0,0 +1,18 @@
+# System.Security.Cryptography.X509Certificates
+
+``` diff
+ namespace System.Security.Cryptography.X509Certificates {
++    public sealed class X509AuthorityInformationAccessExtension : X509Extension {
++        public X509AuthorityInformationAccessExtension();
++        public X509AuthorityInformationAccessExtension(byte[] rawData, bool critical = false);
++        public X509AuthorityInformationAccessExtension(IEnumerable<string>? ocspUris, IEnumerable<string>? caIssuersUris, bool critical = false);
++        public X509AuthorityInformationAccessExtension(ReadOnlySpan<byte> rawData, bool critical = false);
++        public override void CopyFrom(AsnEncodedData asnEncodedData);
++        public IEnumerable<string> EnumerateCAIssuersUris();
++        public IEnumerable<string> EnumerateOcspUris();
++        public IEnumerable<string> EnumerateUris(Oid accessMethodOid);
++        public IEnumerable<string> EnumerateUris(string accessMethodOid);
++    }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md
new file mode 100644
index 00000000..41feda09
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Security.Cryptography.md
@@ -0,0 +1,26 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
+     public sealed class DSACng : DSA {
+-        protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm);
+-        protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm);
+-        protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+     }
+     public sealed class ECDsaCng : ECDsa {
+-        protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm);
+-        protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm);
+-        protected override bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+     }
+     public sealed class RSACng : RSA {
+-        protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm);
+-        protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm);
+-        protected override bool TryHashData(ReadOnlySpan<byte> data, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+     }
+     public sealed class RSACryptoServiceProvider : RSA, ICspAsymmetricAlgorithm {
+-        protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm);
+-        protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md
new file mode 100644
index 00000000..7951d35e
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Nodes.md
@@ -0,0 +1,13 @@
+# System.Text.Json.Nodes
+
+``` diff
+ namespace System.Text.Json.Nodes {
+     public sealed class JsonArray : JsonNode, ICollection<JsonNode?>, IEnumerable, IEnumerable<JsonNode?>, IList<JsonNode?> {
+         public void Add<T>(T value);
+     }
+     public abstract class JsonValue : JsonNode {
+         public static JsonValue Create<T>(T value, JsonNodeOptions? options = default(JsonNodeOptions?));
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md
new file mode 100644
index 00000000..82147c0f
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.Metadata.md
@@ -0,0 +1,13 @@
+# System.Text.Json.Serialization.Metadata
+
+``` diff
+ namespace System.Text.Json.Serialization.Metadata {
+     public static class JsonMetadataServices {
++        public static JsonConverter<DateOnly> DateOnlyConverter { get; }
++        public static JsonConverter<JsonDocument> JsonDocumentConverter { get; }
++        public static JsonConverter<TimeOnly> TimeOnlyConverter { get; }
++        public static JsonTypeInfo<TCollection> CreateIAsyncEnumerableInfo<TCollection, TElement>(JsonSerializerOptions options, JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : IAsyncEnumerable<TElement>;
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md
new file mode 100644
index 00000000..eec8017d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.Serialization.md
@@ -0,0 +1,56 @@
+# System.Text.Json.Serialization
+
+``` diff
+ namespace System.Text.Json.Serialization {
+     public class JsonDerivedTypeAttribute : JsonAttribute {
++        public JsonDerivedTypeAttribute(Type derivedType, int typeDiscriminator);
+-        public JsonDerivedTypeAttribute(Type derivedType, string typeDiscriminatorId);
++        public JsonDerivedTypeAttribute(Type derivedType, string typeDiscriminator);
++        public object? TypeDiscriminator { get; }
+-        public string? TypeDiscriminatorId { get; }
+     }
+     public sealed class JsonPolymorphicAttribute : JsonAttribute {
+-        public string CustomTypeDiscriminatorPropertyName { get; set; }
++        public string TypeDiscriminatorPropertyName { get; set; }
+     }
+-    public class JsonPolymorphicTypeConfiguration : ICollection<(Type, string?)>, IEnumerable, IEnumerable<(Type, string?)> {
++    public class JsonPolymorphicTypeConfiguration : ICollection<(Type, object?)>, IEnumerable, IEnumerable<(Type, object?)> {
+-        public string? CustomTypeDiscriminatorPropertyName { get; set; }
++        int ICollection<(Type, object?)>.Count { get; }
++        bool ICollection<(Type, object?)>.IsReadOnly { get; }
+-        int ICollection<(Type, string?)>.Count { get; }
+-        bool ICollection<(Type, string?)>.IsReadOnly { get; }
++        public string? TypeDiscriminatorPropertyName { get; set; }
++        void ICollection<(Type, object?)>.Add((Type DerivedType, object TypeDiscriminator) item);
++        void ICollection<(Type, object?)>.Clear();
++        bool ICollection<(Type, object?)>.Contains((Type DerivedType, object TypeDiscriminator) item);
++        void ICollection<(Type, object?)>.CopyTo((Type DerivedType, object TypeDiscriminator)[] array, int arrayIndex);
++        bool ICollection<(Type, object?)>.Remove((Type DerivedType, object TypeDiscriminator) item);
+-        void ICollection<(Type, string?)>.Add((Type DerivedType, string TypeDiscriminatorId) item);
+-        void ICollection<(Type, string?)>.Clear();
+-        bool ICollection<(Type, string?)>.Contains((Type DerivedType, string TypeDiscriminatorId) item);
+-        void ICollection<(Type, string?)>.CopyTo((Type DerivedType, string TypeDiscriminatorId)[] array, int arrayIndex);
+-        bool ICollection<(Type, string?)>.Remove((Type DerivedType, string TypeDiscriminatorId) item);
++        IEnumerator<(Type DerivedType, object TypeDiscriminator)> IEnumerable<(Type, object?)>.GetEnumerator();
+-        IEnumerator<(Type DerivedType, string TypeDiscriminatorId)> IEnumerable<(Type, string?)>.GetEnumerator();
++        public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType);
++        public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, int typeDiscriminator);
+-        public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, string? typeDiscriminatorId = null);
++        public JsonPolymorphicTypeConfiguration WithDerivedType(Type derivedType, string typeDiscriminator);
+     }
+     public class JsonPolymorphicTypeConfiguration<TBaseType> : JsonPolymorphicTypeConfiguration where TBaseType : class {
++        public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>() where TDerivedType : TBaseType;
++        public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(int typeDiscriminator) where TDerivedType : TBaseType;
+-        public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(string? typeDiscriminatorId = null) where TDerivedType : TBaseType;
++        public JsonPolymorphicTypeConfiguration<TBaseType> WithDerivedType<TDerivedType>(string typeDiscriminator) where TDerivedType : TBaseType;
+     }
+     public class JsonStringEnumConverter : JsonConverterFactory
+     public enum JsonUnknownDerivedTypeHandling {
+-        FallbackToBaseType = 1,
++        FallBackToBaseType = 1,
+-        FallbackToNearestAncestor = 2,
++        FallBackToNearestAncestor = 2,
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md
new file mode 100644
index 00000000..d210642e
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Text.Json.md
@@ -0,0 +1,53 @@
+# System.Text.Json
+
+``` diff
+ namespace System.Text.Json {
+     public static class JsonSerializer {
+         public static object? Deserialize(Stream utf8Json, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(ReadOnlySpan<byte> utf8Json, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(ReadOnlySpan<char> json, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(string json, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(this JsonDocument document, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(this JsonElement element, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(this JsonNode? node, Type returnType, JsonSerializerOptions? options = null);
+         public static object? Deserialize(ref Utf8JsonReader reader, Type returnType, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(Stream utf8Json, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(ReadOnlySpan<byte> utf8Json, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(ReadOnlySpan<char> json, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(string json, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(this JsonDocument document, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(this JsonElement element, JsonSerializerOptions? options = null);
+         public static TValue? Deserialize<TValue>(this JsonNode? node, 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 IAsyncEnumerable<TValue?> DeserializeAsyncEnumerable<TValue>(Stream utf8Json, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static IAsyncEnumerable<TValue?> DeserializeAsyncEnumerable<TValue>(Stream utf8Json, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default(CancellationToken));
+         public static void Serialize(Stream utf8Json, object? value, Type inputType, JsonSerializerOptions? options = null);
+         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>(Stream utf8Json, TValue value, 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 JsonDocument SerializeToDocument(object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static JsonDocument SerializeToDocument<TValue>(TValue value, JsonSerializerOptions? options = null);
+         public static JsonElement SerializeToElement(object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static JsonElement SerializeToElement<TValue>(TValue value, JsonSerializerOptions? options = null);
+         public static JsonNode? SerializeToNode(object? value, Type inputType, JsonSerializerOptions? options = null);
+         public static JsonNode? SerializeToNode<TValue>(TValue value, JsonSerializerOptions? options = null);
+         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 JsonConverter GetConverter(Type typeToConvert);
+     }
+     public ref struct Utf8JsonReader {
++        public bool ValueIsEscaped { get; }
++        public int CopyString(Span<byte> utf8Destination);
++        public int CopyString(Span<char> destination);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md
new file mode 100644
index 00000000..bfbb8116
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.Threading.md
@@ -0,0 +1,11 @@
+# System.Threading
+
+``` diff
+ namespace System.Threading {
+     public static class Interlocked {
++        public static UIntPtr CompareExchange(ref UIntPtr location1, UIntPtr value, UIntPtr comparand);
++        public static UIntPtr Exchange(ref UIntPtr location1, UIntPtr value);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md
new file mode 100644
index 00000000..be7ad90d
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.NETCore.App/7.0-preview5_System.md
@@ -0,0 +1,1118 @@
+# System
+
+``` diff
+ namespace System {
+     public readonly struct Byte : IAdditionOperators<byte, byte, byte>, IAdditiveIdentity<byte, byte>, IBinaryInteger<byte>, IBinaryNumber<byte>, IBitwiseOperators<byte, byte, byte>, IComparable, IComparable<byte>, IComparisonOperators<byte, byte>, IConvertible, IDecrementOperators<byte>, IDivisionOperators<byte, byte, byte>, IEqualityOperators<byte, byte>, IEquatable<byte>, IFormattable, IIncrementOperators<byte>, IMinMaxValue<byte>, IModulusOperators<byte, byte, byte>, IMultiplicativeIdentity<byte, byte>, IMultiplyOperators<byte, byte, byte>, INumber<byte>, INumberBase<byte>, IParsable<byte>, IShiftOperators<byte, byte>, ISpanFormattable, ISpanParsable<byte>, ISubtractionOperators<byte, byte, byte>, IUnaryNegationOperators<byte, byte>, IUnaryPlusOperators<byte, byte>, IUnsignedNumber<byte> {
++        static int System.Numerics.INumberBase<System.Byte>.Radix { get; }
+-        public static byte CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static byte CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static byte CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(byte value);
++        public static bool IsOddInteger(byte value);
+-        long IBinaryInteger<byte>.GetShortestBitLength();
++        int IBinaryInteger<byte>.GetShortestBitLength();
++        bool IBinaryInteger<byte>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static byte INumber<byte>.Abs(byte value);
+-        static bool INumber<byte>.IsNegative(byte value);
+-        static byte INumber<byte>.MaxMagnitude(byte x, byte y);
++        static byte INumber<byte>.MaxNumber(byte x, byte y);
+-        static byte INumber<byte>.MinMagnitude(byte x, byte y);
++        static byte INumber<byte>.MinNumber(byte x, byte y);
++        static byte INumberBase<byte>.Abs(byte value);
++        static bool INumberBase<byte>.IsCanonical(byte value);
++        static bool INumberBase<byte>.IsComplexNumber(byte value);
++        static bool INumberBase<byte>.IsFinite(byte value);
++        static bool INumberBase<byte>.IsImaginaryNumber(byte value);
++        static bool INumberBase<byte>.IsInfinity(byte value);
++        static bool INumberBase<byte>.IsInteger(byte value);
++        static bool INumberBase<byte>.IsNaN(byte value);
++        static bool INumberBase<byte>.IsNegative(byte value);
++        static bool INumberBase<byte>.IsNegativeInfinity(byte value);
++        static bool INumberBase<byte>.IsNormal(byte value);
++        static bool INumberBase<byte>.IsPositive(byte value);
++        static bool INumberBase<byte>.IsPositiveInfinity(byte value);
++        static bool INumberBase<byte>.IsRealNumber(byte value);
++        static bool INumberBase<byte>.IsSubnormal(byte value);
++        static bool INumberBase<byte>.IsZero(byte value);
++        static byte INumberBase<byte>.MaxMagnitude(byte x, byte y);
++        static byte INumberBase<byte>.MaxMagnitudeNumber(byte x, byte y);
++        static byte INumberBase<byte>.MinMagnitude(byte x, byte y);
++        static byte INumberBase<byte>.MinMagnitudeNumber(byte x, byte y);
++        static bool INumberBase<byte>.TryConvertFromChecked<TOther>(TOther value, out byte result);
++        static bool INumberBase<byte>.TryConvertFromSaturating<TOther>(TOther value, out byte result);
++        static bool INumberBase<byte>.TryConvertFromTruncating<TOther>(TOther value, out byte result);
++        static bool INumberBase<byte>.TryConvertToChecked<TOther>(byte value, out TOther result);
++        static bool INumberBase<byte>.TryConvertToSaturating<TOther>(byte value, out TOther result);
++        static bool INumberBase<byte>.TryConvertToTruncating<TOther>(byte value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out byte result) where TOther : INumber<TOther>;
+     }
+     public readonly struct Char : IAdditionOperators<char, char, char>, IAdditiveIdentity<char, char>, IBinaryInteger<char>, IBinaryNumber<char>, IBitwiseOperators<char, char, char>, IComparable, IComparable<char>, IComparisonOperators<char, char>, IConvertible, IDecrementOperators<char>, IDivisionOperators<char, char, char>, IEqualityOperators<char, char>, IEquatable<char>, IFormattable, IIncrementOperators<char>, IMinMaxValue<char>, IModulusOperators<char, char, char>, IMultiplicativeIdentity<char, char>, IMultiplyOperators<char, char, char>, INumber<char>, INumberBase<char>, IParsable<char>, IShiftOperators<char, char>, ISpanFormattable, ISpanParsable<char>, ISubtractionOperators<char, char, char>, IUnaryNegationOperators<char, char>, IUnaryPlusOperators<char, char>, IUnsignedNumber<char> {
++        static int System.Numerics.INumberBase<System.Char>.Radix { get; }
+-        public static char Clamp(char value, char min, char max);
+-        public static char CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static char CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static char CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static (char Quotient, char Remainder) DivRem(char left, char right);
++        public static bool IsAsciiDigit(char c);
++        public static bool IsAsciiHexDigit(char c);
++        public static bool IsAsciiHexDigitLower(char c);
++        public static bool IsAsciiHexDigitUpper(char c);
++        public static bool IsAsciiLetter(char c);
++        public static bool IsAsciiLetterLower(char c);
++        public static bool IsAsciiLetterOrDigit(char c);
++        public static bool IsAsciiLetterUpper(char c);
++        public static bool IsBetween(char c, char minInclusive, char maxInclusive);
+-        public static bool IsPow2(char value);
+-        public static char LeadingZeroCount(char value);
+-        public static char Log2(char value);
+-        public static char Max(char x, char y);
+-        public static char Min(char x, char y);
+-        public static char PopCount(char value);
+-        public static char RotateLeft(char value, int rotateAmount);
+-        public static char RotateRight(char value, int rotateAmount);
+-        public static int Sign(char value);
++        static (char Quotient, char Remainder) IBinaryInteger<char>.DivRem(char left, char right);
+-        long IBinaryInteger<char>.GetShortestBitLength();
++        int IBinaryInteger<char>.GetShortestBitLength();
++        static char IBinaryInteger<char>.LeadingZeroCount(char value);
++        static char IBinaryInteger<char>.PopCount(char value);
++        static char IBinaryInteger<char>.RotateLeft(char value, int rotateAmount);
++        static char IBinaryInteger<char>.RotateRight(char value, int rotateAmount);
++        static char IBinaryInteger<char>.TrailingZeroCount(char value);
++        bool IBinaryInteger<char>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool IBinaryNumber<char>.IsPow2(char value);
++        static char IBinaryNumber<char>.Log2(char value);
+-        static char INumber<char>.Abs(char value);
++        static char INumber<char>.Clamp(char value, char min, char max);
+-        static bool INumber<char>.IsNegative(char value);
++        static char INumber<char>.Max(char x, char y);
+-        static char INumber<char>.MaxMagnitude(char x, char y);
++        static char INumber<char>.MaxNumber(char x, char y);
++        static char INumber<char>.Min(char x, char y);
+-        static char INumber<char>.MinMagnitude(char x, char y);
++        static char INumber<char>.MinNumber(char x, char y);
+-        static char INumber<char>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider);
+-        static char INumber<char>.Parse(string s, NumberStyles style, IFormatProvider provider);
++        static int INumber<char>.Sign(char value);
+-        static bool INumber<char>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out char result);
+-        static bool INumber<char>.TryParse(string s, NumberStyles style, IFormatProvider provider, out char result);
++        static char INumberBase<char>.Abs(char value);
++        static bool INumberBase<char>.IsCanonical(char value);
++        static bool INumberBase<char>.IsComplexNumber(char value);
++        static bool INumberBase<char>.IsEvenInteger(char value);
++        static bool INumberBase<char>.IsFinite(char value);
++        static bool INumberBase<char>.IsImaginaryNumber(char value);
++        static bool INumberBase<char>.IsInfinity(char value);
++        static bool INumberBase<char>.IsInteger(char value);
++        static bool INumberBase<char>.IsNaN(char value);
++        static bool INumberBase<char>.IsNegative(char value);
++        static bool INumberBase<char>.IsNegativeInfinity(char value);
++        static bool INumberBase<char>.IsNormal(char value);
++        static bool INumberBase<char>.IsOddInteger(char value);
++        static bool INumberBase<char>.IsPositive(char value);
++        static bool INumberBase<char>.IsPositiveInfinity(char value);
++        static bool INumberBase<char>.IsRealNumber(char value);
++        static bool INumberBase<char>.IsSubnormal(char value);
++        static bool INumberBase<char>.IsZero(char value);
++        static char INumberBase<char>.MaxMagnitude(char x, char y);
++        static char INumberBase<char>.MaxMagnitudeNumber(char x, char y);
++        static char INumberBase<char>.MinMagnitude(char x, char y);
++        static char INumberBase<char>.MinMagnitudeNumber(char x, char y);
++        static char INumberBase<char>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider);
++        static char INumberBase<char>.Parse(string s, NumberStyles style, IFormatProvider provider);
++        static bool INumberBase<char>.TryConvertFromChecked<TOther>(TOther value, out char result);
++        static bool INumberBase<char>.TryConvertFromSaturating<TOther>(TOther value, out char result);
++        static bool INumberBase<char>.TryConvertFromTruncating<TOther>(TOther value, out char result);
++        static bool INumberBase<char>.TryConvertToChecked<TOther>(char value, out TOther result);
++        static bool INumberBase<char>.TryConvertToSaturating<TOther>(char value, out TOther result);
++        static bool INumberBase<char>.TryConvertToTruncating<TOther>(char value, out TOther result);
++        static bool INumberBase<char>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out char result);
++        static bool INumberBase<char>.TryParse(string s, NumberStyles style, IFormatProvider provider, out char result);
+-        public static char TrailingZeroCount(char value);
+-        public static bool TryCreate<TOther>(TOther value, out char result) where TOther : INumber<TOther>;
+     }
+-    public readonly struct DateOnly : IComparable, IComparable<DateOnly>, IComparisonOperators<DateOnly, DateOnly>, IEqualityOperators<DateOnly, DateOnly>, IEquatable<DateOnly>, IFormattable, IMinMaxValue<DateOnly>, IParsable<DateOnly>, ISpanFormattable, ISpanParsable<DateOnly>
++    public readonly struct DateOnly : IComparable, IComparable<DateOnly>, IEquatable<DateOnly>, IFormattable, IParsable<DateOnly>, ISpanFormattable, ISpanParsable<DateOnly>
+-    public readonly struct DateTime : IAdditionOperators<DateTime, TimeSpan, DateTime>, IAdditiveIdentity<DateTime, TimeSpan>, IComparable, IComparable<DateTime>, IComparisonOperators<DateTime, DateTime>, IConvertible, IEqualityOperators<DateTime, DateTime>, IEquatable<DateTime>, IFormattable, IMinMaxValue<DateTime>, IParsable<DateTime>, ISerializable, ISpanFormattable, ISpanParsable<DateTime>, ISubtractionOperators<DateTime, DateTime, TimeSpan>, ISubtractionOperators<DateTime, TimeSpan, DateTime> {
++    public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, IParsable<DateTime>, ISerializable, ISpanFormattable, ISpanParsable<DateTime> {
+-        static TimeSpan System.Numerics.IAdditiveIdentity<System.DateTime,System.TimeSpan>.AdditiveIdentity { get; }
+-        static DateTime System.Numerics.IMinMaxValue<System.DateTime>.MaxValue { get; }
+-        static DateTime System.Numerics.IMinMaxValue<System.DateTime>.MinValue { get; }
+-        static DateTime IAdditionOperators<DateTime, TimeSpan, DateTime>.operator checked +(DateTime left, TimeSpan right);
+-        static TimeSpan ISubtractionOperators<DateTime, DateTime, TimeSpan>.operator checked -(DateTime left, DateTime right);
+-        static DateTime ISubtractionOperators<DateTime, TimeSpan, DateTime>.operator checked -(DateTime left, TimeSpan right);
+     }
+-    public readonly struct DateTimeOffset : IAdditionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>, IAdditiveIdentity<DateTimeOffset, TimeSpan>, IComparable, IComparable<DateTimeOffset>, IComparisonOperators<DateTimeOffset, DateTimeOffset>, IDeserializationCallback, IEqualityOperators<DateTimeOffset, DateTimeOffset>, IEquatable<DateTimeOffset>, IFormattable, IMinMaxValue<DateTimeOffset>, IParsable<DateTimeOffset>, ISerializable, ISpanFormattable, ISpanParsable<DateTimeOffset>, ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>, ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset> {
++    public readonly struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, IParsable<DateTimeOffset>, ISerializable, ISpanFormattable, ISpanParsable<DateTimeOffset> {
+-        static TimeSpan System.Numerics.IAdditiveIdentity<System.DateTimeOffset,System.TimeSpan>.AdditiveIdentity { get; }
+-        static DateTimeOffset System.Numerics.IMinMaxValue<System.DateTimeOffset>.MaxValue { get; }
+-        static DateTimeOffset System.Numerics.IMinMaxValue<System.DateTimeOffset>.MinValue { get; }
+-        static DateTimeOffset IAdditionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>.operator checked +(DateTimeOffset left, TimeSpan right);
+-        static TimeSpan ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>.operator checked -(DateTimeOffset left, DateTimeOffset right);
+-        static DateTimeOffset ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>.operator checked -(DateTimeOffset left, TimeSpan right);
+     }
+     public readonly struct Decimal : IAdditionOperators<decimal, decimal, decimal>, IAdditiveIdentity<decimal, decimal>, IComparable, IComparable<decimal>, IComparisonOperators<decimal, decimal>, IConvertible, IDecrementOperators<decimal>, IDeserializationCallback, IDivisionOperators<decimal, decimal, decimal>, IEqualityOperators<decimal, decimal>, IEquatable<decimal>, IFloatingPoint<decimal>, IFormattable, IIncrementOperators<decimal>, IMinMaxValue<decimal>, IModulusOperators<decimal, decimal, decimal>, IMultiplicativeIdentity<decimal, decimal>, IMultiplyOperators<decimal, decimal, decimal>, INumber<decimal>, INumberBase<decimal>, IParsable<decimal>, ISerializable, ISignedNumber<decimal>, ISpanFormattable, ISpanParsable<decimal>, ISubtractionOperators<decimal, decimal, decimal>, IUnaryNegationOperators<decimal, decimal>, IUnaryPlusOperators<decimal, decimal> {
++        static int System.Numerics.INumberBase<System.Decimal>.Radix { get; }
+-        public static decimal CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static decimal CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static decimal CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsCanonical(decimal value);
++        public static bool IsEvenInteger(decimal value);
++        public static bool IsInteger(decimal value);
++        public static bool IsOddInteger(decimal value);
++        public static bool IsPositive(decimal value);
+-        long IFloatingPoint<decimal>.GetExponentShortestBitLength();
++        int IFloatingPoint<decimal>.GetExponentShortestBitLength();
+-        long IFloatingPoint<decimal>.GetSignificandBitLength();
++        int IFloatingPoint<decimal>.GetSignificandBitLength();
++        bool IFloatingPoint<decimal>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<decimal>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static decimal INumber<decimal>.MaxNumber(decimal x, decimal y);
++        static decimal INumber<decimal>.MinNumber(decimal x, decimal y);
++        static bool INumberBase<decimal>.IsComplexNumber(decimal value);
++        static bool INumberBase<decimal>.IsFinite(decimal value);
++        static bool INumberBase<decimal>.IsImaginaryNumber(decimal value);
++        static bool INumberBase<decimal>.IsInfinity(decimal value);
++        static bool INumberBase<decimal>.IsNaN(decimal value);
++        static bool INumberBase<decimal>.IsNegativeInfinity(decimal value);
++        static bool INumberBase<decimal>.IsNormal(decimal value);
++        static bool INumberBase<decimal>.IsPositiveInfinity(decimal value);
++        static bool INumberBase<decimal>.IsRealNumber(decimal value);
++        static bool INumberBase<decimal>.IsSubnormal(decimal value);
++        static bool INumberBase<decimal>.IsZero(decimal value);
++        static decimal INumberBase<decimal>.MaxMagnitudeNumber(decimal x, decimal y);
++        static decimal INumberBase<decimal>.MinMagnitudeNumber(decimal x, decimal y);
++        static bool INumberBase<decimal>.TryConvertFromChecked<TOther>(TOther value, out decimal result);
++        static bool INumberBase<decimal>.TryConvertFromSaturating<TOther>(TOther value, out decimal result);
++        static bool INumberBase<decimal>.TryConvertFromTruncating<TOther>(TOther value, out decimal result);
++        static bool INumberBase<decimal>.TryConvertToChecked<TOther>(decimal value, out TOther result);
++        static bool INumberBase<decimal>.TryConvertToSaturating<TOther>(decimal value, out TOther result);
++        static bool INumberBase<decimal>.TryConvertToTruncating<TOther>(decimal value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out decimal result) where TOther : INumber<TOther>;
+     }
+     public readonly struct Double : IAdditionOperators<double, double, double>, IAdditiveIdentity<double, double>, IBinaryFloatingPointIeee754<double>, IBinaryNumber<double>, IBitwiseOperators<double, double, double>, IComparable, IComparable<double>, IComparisonOperators<double, double>, IConvertible, IDecrementOperators<double>, IDivisionOperators<double, double, double>, IEqualityOperators<double, double>, IEquatable<double>, IExponentialFunctions<double>, IFloatingPoint<double>, IFloatingPointIeee754<double>, IFormattable, IHyperbolicFunctions<double>, IIncrementOperators<double>, ILogarithmicFunctions<double>, IMinMaxValue<double>, IModulusOperators<double, double, double>, IMultiplicativeIdentity<double, double>, IMultiplyOperators<double, double, double>, INumber<double>, INumberBase<double>, IParsable<double>, IPowerFunctions<double>, IRootFunctions<double>, ISignedNumber<double>, ISpanFormattable, ISpanParsable<double>, ISubtractionOperators<double, double, double>, ITrigonometricFunctions<double>, IUnaryNegationOperators<double, double>, IUnaryPlusOperators<double, double> {
++        static int System.Numerics.INumberBase<System.Double>.Radix { get; }
+-        public static double CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static double CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static double CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static double Exp10(double x);
++        public static double Exp10M1(double x);
++        public static double Exp2(double x);
++        public static double Exp2M1(double x);
++        public static double ExpM1(double x);
++        public static bool IsEvenInteger(double value);
++        public static bool IsInteger(double value);
++        public static bool IsOddInteger(double value);
++        public static bool IsPositive(double value);
++        public static bool IsRealNumber(double value);
++        public static double Log10P1(double x);
++        public static double Log2P1(double x);
++        public static double LogP1(double x);
++        public static double MaxMagnitudeNumber(double x, double y);
++        public static double MaxNumber(double x, double y);
++        public static double MinMagnitudeNumber(double x, double y);
++        public static double MinNumber(double x, double y);
+-        long IFloatingPoint<double>.GetExponentShortestBitLength();
++        int IFloatingPoint<double>.GetExponentShortestBitLength();
+-        long IFloatingPoint<double>.GetSignificandBitLength();
++        int IFloatingPoint<double>.GetSignificandBitLength();
++        bool IFloatingPoint<double>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<double>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool INumberBase<double>.IsCanonical(double value);
++        static bool INumberBase<double>.IsComplexNumber(double value);
++        static bool INumberBase<double>.IsImaginaryNumber(double value);
++        static bool INumberBase<double>.IsZero(double value);
++        static bool INumberBase<double>.TryConvertFromChecked<TOther>(TOther value, out double result);
++        static bool INumberBase<double>.TryConvertFromSaturating<TOther>(TOther value, out double result);
++        static bool INumberBase<double>.TryConvertFromTruncating<TOther>(TOther value, out double result);
++        static bool INumberBase<double>.TryConvertToChecked<TOther>(double value, out TOther result);
++        static bool INumberBase<double>.TryConvertToSaturating<TOther>(double value, out TOther result);
++        static bool INumberBase<double>.TryConvertToTruncating<TOther>(double value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out double result) where TOther : INumber<TOther>;
+     }
+     public static class GC {
++        public static TimeSpan GetTotalPauseDuration();
+     }
+-    public readonly struct Guid : IComparable, IComparable<Guid>, IComparisonOperators<Guid, Guid>, IEqualityOperators<Guid, Guid>, IEquatable<Guid>, IFormattable, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>
++    public readonly struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>
+     public readonly struct Half : IAdditionOperators<Half, Half, Half>, IAdditiveIdentity<Half, Half>, IBinaryFloatingPointIeee754<Half>, IBinaryNumber<Half>, IBitwiseOperators<Half, Half, Half>, IComparable, IComparable<Half>, IComparisonOperators<Half, Half>, IDecrementOperators<Half>, IDivisionOperators<Half, Half, Half>, IEqualityOperators<Half, Half>, IEquatable<Half>, IExponentialFunctions<Half>, IFloatingPoint<Half>, IFloatingPointIeee754<Half>, IFormattable, IHyperbolicFunctions<Half>, IIncrementOperators<Half>, ILogarithmicFunctions<Half>, IMinMaxValue<Half>, IModulusOperators<Half, Half, Half>, IMultiplicativeIdentity<Half, Half>, IMultiplyOperators<Half, Half, Half>, INumber<Half>, INumberBase<Half>, IParsable<Half>, IPowerFunctions<Half>, IRootFunctions<Half>, ISignedNumber<Half>, ISpanFormattable, ISpanParsable<Half>, ISubtractionOperators<Half, Half, Half>, ITrigonometricFunctions<Half>, IUnaryNegationOperators<Half, Half>, IUnaryPlusOperators<Half, Half> {
++        public static Half NegativeOne { get; }
++        public static Half One { get; }
+-        static Half System.Numerics.INumberBase<System.Half>.One { get; }
++        static int System.Numerics.INumberBase<System.Half>.Radix { get; }
+-        static Half System.Numerics.INumberBase<System.Half>.Zero { get; }
+-        static Half System.Numerics.ISignedNumber<System.Half>.NegativeOne { get; }
++        public static Half Zero { get; }
+-        public static Half CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static Half CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static Half CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static Half Exp10(Half x);
++        public static Half Exp10M1(Half x);
++        public static Half Exp2(Half x);
++        public static Half Exp2M1(Half x);
++        public static Half ExpM1(Half x);
++        public static bool IsEvenInteger(Half value);
++        public static bool IsInteger(Half value);
++        public static bool IsOddInteger(Half value);
++        public static bool IsPositive(Half value);
++        public static bool IsRealNumber(Half value);
++        public static Half Log10P1(Half x);
++        public static Half Log2P1(Half x);
++        public static Half LogP1(Half x);
++        public static Half MaxMagnitudeNumber(Half x, Half y);
++        public static Half MaxNumber(Half x, Half y);
++        public static Half MinMagnitudeNumber(Half x, Half y);
++        public static Half MinNumber(Half x, Half y);
++        public static explicit operator checked byte (Half value);
++        public static explicit operator checked char (Half value);
++        public static explicit operator checked short (Half value);
++        public static explicit operator checked int (Half value);
++        public static explicit operator checked long (Half value);
++        public static explicit operator checked Int128 (Half value);
++        public static explicit operator checked IntPtr (Half value);
++        public static explicit operator checked sbyte (Half value);
++        public static explicit operator checked ushort (Half value);
++        public static explicit operator checked uint (Half value);
++        public static explicit operator checked ulong (Half value);
++        public static explicit operator checked UInt128 (Half value);
++        public static explicit operator checked UIntPtr (Half value);
++        public static explicit operator Half (char value);
++        public static explicit operator Half (decimal value);
++        public static explicit operator byte (Half value);
++        public static explicit operator char (Half value);
++        public static explicit operator decimal (Half value);
++        public static explicit operator Int128 (Half value);
++        public static explicit operator short (Half value);
++        public static explicit operator int (Half value);
++        public static explicit operator long (Half value);
++        public static explicit operator IntPtr (Half value);
++        public static explicit operator sbyte (Half value);
++        public static explicit operator UInt128 (Half value);
++        public static explicit operator ushort (Half value);
++        public static explicit operator uint (Half value);
++        public static explicit operator ulong (Half value);
++        public static explicit operator UIntPtr (Half value);
++        public static explicit operator Half (short value);
++        public static explicit operator Half (int value);
++        public static explicit operator Half (long value);
++        public static explicit operator Half (IntPtr value);
++        public static explicit operator Half (ushort value);
++        public static explicit operator Half (uint value);
++        public static explicit operator Half (ulong value);
++        public static explicit operator Half (UIntPtr value);
++        public static implicit operator Half (byte value);
++        public static implicit operator Half (sbyte value);
+-        long IFloatingPoint<Half>.GetExponentShortestBitLength();
++        int IFloatingPoint<Half>.GetExponentShortestBitLength();
+-        long IFloatingPoint<Half>.GetSignificandBitLength();
++        int IFloatingPoint<Half>.GetSignificandBitLength();
++        bool IFloatingPoint<Half>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<Half>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool INumberBase<Half>.IsCanonical(Half value);
++        static bool INumberBase<Half>.IsComplexNumber(Half value);
++        static bool INumberBase<Half>.IsImaginaryNumber(Half value);
++        static bool INumberBase<Half>.IsZero(Half value);
++        static bool INumberBase<Half>.TryConvertFromChecked<TOther>(TOther value, out Half result);
++        static bool INumberBase<Half>.TryConvertFromSaturating<TOther>(TOther value, out Half result);
++        static bool INumberBase<Half>.TryConvertFromTruncating<TOther>(TOther value, out Half result);
++        static bool INumberBase<Half>.TryConvertToChecked<TOther>(Half value, out TOther result);
++        static bool INumberBase<Half>.TryConvertToSaturating<TOther>(Half value, out TOther result);
++        static bool INumberBase<Half>.TryConvertToTruncating<TOther>(Half value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out Half result) where TOther : INumber<TOther>;
+     }
++    public readonly struct Int128 : IAdditionOperators<Int128, Int128, Int128>, IAdditiveIdentity<Int128, Int128>, IBinaryInteger<Int128>, IBinaryNumber<Int128>, IBitwiseOperators<Int128, Int128, Int128>, IComparable, IComparable<Int128>, IComparisonOperators<Int128, Int128>, IDecrementOperators<Int128>, IDivisionOperators<Int128, Int128, Int128>, IEqualityOperators<Int128, Int128>, IEquatable<Int128>, IFormattable, IIncrementOperators<Int128>, IMinMaxValue<Int128>, IModulusOperators<Int128, Int128, Int128>, IMultiplicativeIdentity<Int128, Int128>, IMultiplyOperators<Int128, Int128, Int128>, INumber<Int128>, INumberBase<Int128>, IParsable<Int128>, IShiftOperators<Int128, Int128>, ISignedNumber<Int128>, ISpanFormattable, ISpanParsable<Int128>, ISubtractionOperators<Int128, Int128, Int128>, IUnaryNegationOperators<Int128, Int128>, IUnaryPlusOperators<Int128, Int128> {
++        public Int128(ulong upper, ulong lower);
++        public static Int128 MaxValue { get; }
++        public static Int128 MinValue { get; }
++        public static Int128 NegativeOne { get; }
++        public static Int128 One { get; }
++        static Int128 System.Numerics.IAdditiveIdentity<System.Int128,System.Int128>.AdditiveIdentity { get; }
++        static Int128 System.Numerics.IMultiplicativeIdentity<System.Int128,System.Int128>.MultiplicativeIdentity { get; }
++        static int System.Numerics.INumberBase<System.Int128>.Radix { get; }
++        public static Int128 Zero { get; }
++        public static Int128 Abs(Int128 value);
++        public static Int128 Clamp(Int128 value, Int128 min, Int128 max);
++        public int CompareTo(Int128 value);
++        public int CompareTo(object? value);
++        public static Int128 CopySign(Int128 value, Int128 sign);
++        public static (Int128 Quotient, Int128 Remainder) DivRem(Int128 left, Int128 right);
++        public bool Equals(Int128 other);
++        public override bool Equals(object? obj);
++        public override int GetHashCode();
++        public static bool IsEvenInteger(Int128 value);
++        public static bool IsNegative(Int128 value);
++        public static bool IsOddInteger(Int128 value);
++        public static bool IsPositive(Int128 value);
++        public static bool IsPow2(Int128 value);
++        public static Int128 LeadingZeroCount(Int128 value);
++        public static Int128 Log2(Int128 value);
++        public static Int128 Max(Int128 x, Int128 y);
++        public static Int128 MaxMagnitude(Int128 x, Int128 y);
++        public static Int128 Min(Int128 x, Int128 y);
++        public static Int128 MinMagnitude(Int128 x, Int128 y);
++        public static Int128 operator +(Int128 left, Int128 right);
++        public static Int128 operator &(Int128 left, Int128 right);
++        public static Int128 operator |(Int128 left, Int128 right);
++        public static Int128 operator checked +(Int128 left, Int128 right);
++        public static Int128 operator checked --(Int128 value);
++        public static Int128 operator checked /(Int128 left, Int128 right);
++        public static explicit operator checked Int128 (double value);
++        public static explicit operator checked byte (Int128 value);
++        public static explicit operator checked char (Int128 value);
++        public static explicit operator checked short (Int128 value);
++        public static explicit operator checked int (Int128 value);
++        public static explicit operator checked long (Int128 value);
++        public static explicit operator checked nint (Int128 value);
++        public static explicit operator checked sbyte (Int128 value);
++        public static explicit operator checked ushort (Int128 value);
++        public static explicit operator checked uint (Int128 value);
++        public static explicit operator checked ulong (Int128 value);
++        public static explicit operator checked UInt128 (Int128 value);
++        public static explicit operator checked nuint (Int128 value);
++        public static explicit operator checked Int128 (float value);
++        public static Int128 operator checked ++(Int128 value);
++        public static Int128 operator checked *(Int128 left, Int128 right);
++        public static Int128 operator checked -(Int128 left, Int128 right);
++        public static Int128 operator checked -(Int128 value);
++        public static Int128 operator --(Int128 value);
++        public static Int128 operator /(Int128 left, Int128 right);
++        public static bool operator ==(Int128 left, Int128 right);
++        public static Int128 operator ^(Int128 left, Int128 right);
++        public static explicit operator Int128 (decimal value);
++        public static explicit operator Int128 (double value);
++        public static explicit operator byte (Int128 value);
++        public static explicit operator char (Int128 value);
++        public static explicit operator decimal (Int128 value);
++        public static explicit operator double (Int128 value);
++        public static explicit operator Half (Int128 value);
++        public static explicit operator short (Int128 value);
++        public static explicit operator int (Int128 value);
++        public static explicit operator long (Int128 value);
++        public static explicit operator nint (Int128 value);
++        public static explicit operator sbyte (Int128 value);
++        public static explicit operator float (Int128 value);
++        public static explicit operator UInt128 (Int128 value);
++        public static explicit operator ushort (Int128 value);
++        public static explicit operator uint (Int128 value);
++        public static explicit operator ulong (Int128 value);
++        public static explicit operator nuint (Int128 value);
++        public static explicit operator Int128 (float value);
++        public static bool operator >(Int128 left, Int128 right);
++        public static bool operator >=(Int128 left, Int128 right);
++        public static implicit operator Int128 (byte value);
++        public static implicit operator Int128 (char value);
++        public static implicit operator Int128 (short value);
++        public static implicit operator Int128 (int value);
++        public static implicit operator Int128 (long value);
++        public static implicit operator Int128 (nint value);
++        public static implicit operator Int128 (sbyte value);
++        public static implicit operator Int128 (ushort value);
++        public static implicit operator Int128 (uint value);
++        public static implicit operator Int128 (ulong value);
++        public static implicit operator Int128 (nuint value);
++        public static Int128 operator ++(Int128 value);
++        public static bool operator !=(Int128 left, Int128 right);
++        public static Int128 operator <<(Int128 value, int shiftAmount);
++        public static bool operator <(Int128 left, Int128 right);
++        public static bool operator <=(Int128 left, Int128 right);
++        public static Int128 operator %(Int128 left, Int128 right);
++        public static Int128 operator *(Int128 left, Int128 right);
++        public static Int128 operator ~(Int128 value);
++        public static Int128 operator >>(Int128 value, int shiftAmount);
++        public static Int128 operator -(Int128 left, Int128 right);
++        public static Int128 operator -(Int128 value);
++        public static Int128 operator +(Int128 value);
++        public static Int128 operator >>>(Int128 value, int shiftAmount);
++        public static Int128 Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null);
++        public static Int128 Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
++        public static Int128 Parse(string s);
++        public static Int128 Parse(string s, NumberStyles style);
++        public static Int128 Parse(string s, NumberStyles style, IFormatProvider? provider);
++        public static Int128 Parse(string s, IFormatProvider? provider);
++        public static Int128 PopCount(Int128 value);
++        public static Int128 RotateLeft(Int128 value, int rotateAmount);
++        public static Int128 RotateRight(Int128 value, int rotateAmount);
++        public static int Sign(Int128 value);
++        int IBinaryInteger<Int128>.GetByteCount();
++        int IBinaryInteger<Int128>.GetShortestBitLength();
++        bool IBinaryInteger<Int128>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IBinaryInteger<Int128>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten);
++        static Int128 INumber<Int128>.MaxNumber(Int128 x, Int128 y);
++        static Int128 INumber<Int128>.MinNumber(Int128 x, Int128 y);
++        static bool INumberBase<Int128>.IsCanonical(Int128 value);
++        static bool INumberBase<Int128>.IsComplexNumber(Int128 value);
++        static bool INumberBase<Int128>.IsFinite(Int128 value);
++        static bool INumberBase<Int128>.IsImaginaryNumber(Int128 value);
++        static bool INumberBase<Int128>.IsInfinity(Int128 value);
++        static bool INumberBase<Int128>.IsInteger(Int128 value);
++        static bool INumberBase<Int128>.IsNaN(Int128 value);
++        static bool INumberBase<Int128>.IsNegativeInfinity(Int128 value);
++        static bool INumberBase<Int128>.IsNormal(Int128 value);
++        static bool INumberBase<Int128>.IsPositiveInfinity(Int128 value);
++        static bool INumberBase<Int128>.IsRealNumber(Int128 value);
++        static bool INumberBase<Int128>.IsSubnormal(Int128 value);
++        static bool INumberBase<Int128>.IsZero(Int128 value);
++        static Int128 INumberBase<Int128>.MaxMagnitudeNumber(Int128 x, Int128 y);
++        static Int128 INumberBase<Int128>.MinMagnitudeNumber(Int128 x, Int128 y);
++        static bool INumberBase<Int128>.TryConvertFromChecked<TOther>(TOther value, out Int128 result);
++        static bool INumberBase<Int128>.TryConvertFromSaturating<TOther>(TOther value, out Int128 result);
++        static bool INumberBase<Int128>.TryConvertFromTruncating<TOther>(TOther value, out Int128 result);
++        static bool INumberBase<Int128>.TryConvertToChecked<TOther>(Int128 value, out TOther result);
++        static bool INumberBase<Int128>.TryConvertToSaturating<TOther>(Int128 value, out TOther result);
++        static bool INumberBase<Int128>.TryConvertToTruncating<TOther>(Int128 value, out TOther result);
++        public override string ToString();
++        public string ToString(IFormatProvider? provider);
++        public string ToString(string? format);
++        public string ToString(string? format, IFormatProvider? provider);
++        public static Int128 TrailingZeroCount(Int128 value);
++        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null);
++        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out Int128 result);
++        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out Int128 result);
++        public static bool TryParse(ReadOnlySpan<char> s, out Int128 result);
++        public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out Int128 result);
++        public static bool TryParse(string? s, IFormatProvider? provider, out Int128 result);
++        public static bool TryParse(string? s, out Int128 result);
++    }
+     public readonly struct Int16 : IAdditionOperators<short, short, short>, IAdditiveIdentity<short, short>, IBinaryInteger<short>, IBinaryNumber<short>, IBitwiseOperators<short, short, short>, IComparable, IComparable<short>, IComparisonOperators<short, short>, IConvertible, IDecrementOperators<short>, IDivisionOperators<short, short, short>, IEqualityOperators<short, short>, IEquatable<short>, IFormattable, IIncrementOperators<short>, IMinMaxValue<short>, IModulusOperators<short, short, short>, IMultiplicativeIdentity<short, short>, IMultiplyOperators<short, short, short>, INumber<short>, INumberBase<short>, IParsable<short>, IShiftOperators<short, short>, ISignedNumber<short>, ISpanFormattable, ISpanParsable<short>, ISubtractionOperators<short, short, short>, IUnaryNegationOperators<short, short>, IUnaryPlusOperators<short, short> {
++        static int System.Numerics.INumberBase<System.Int16>.Radix { get; }
+-        public static short CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static short CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static short CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(short value);
++        public static bool IsOddInteger(short value);
++        public static bool IsPositive(short value);
+-        long IBinaryInteger<short>.GetShortestBitLength();
++        int IBinaryInteger<short>.GetShortestBitLength();
++        bool IBinaryInteger<short>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static short INumber<short>.MaxNumber(short x, short y);
++        static short INumber<short>.MinNumber(short x, short y);
++        static bool INumberBase<short>.IsCanonical(short value);
++        static bool INumberBase<short>.IsComplexNumber(short value);
++        static bool INumberBase<short>.IsFinite(short value);
++        static bool INumberBase<short>.IsImaginaryNumber(short value);
++        static bool INumberBase<short>.IsInfinity(short value);
++        static bool INumberBase<short>.IsInteger(short value);
++        static bool INumberBase<short>.IsNaN(short value);
++        static bool INumberBase<short>.IsNegativeInfinity(short value);
++        static bool INumberBase<short>.IsNormal(short value);
++        static bool INumberBase<short>.IsPositiveInfinity(short value);
++        static bool INumberBase<short>.IsRealNumber(short value);
++        static bool INumberBase<short>.IsSubnormal(short value);
++        static bool INumberBase<short>.IsZero(short value);
++        static short INumberBase<short>.MaxMagnitudeNumber(short x, short y);
++        static short INumberBase<short>.MinMagnitudeNumber(short x, short y);
++        static bool INumberBase<short>.TryConvertFromChecked<TOther>(TOther value, out short result);
++        static bool INumberBase<short>.TryConvertFromSaturating<TOther>(TOther value, out short result);
++        static bool INumberBase<short>.TryConvertFromTruncating<TOther>(TOther value, out short result);
++        static bool INumberBase<short>.TryConvertToChecked<TOther>(short value, out TOther result);
++        static bool INumberBase<short>.TryConvertToSaturating<TOther>(short value, out TOther result);
++        static bool INumberBase<short>.TryConvertToTruncating<TOther>(short value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out short result) where TOther : INumber<TOther>;
+     }
+     public readonly struct Int32 : IAdditionOperators<int, int, int>, IAdditiveIdentity<int, int>, IBinaryInteger<int>, IBinaryNumber<int>, IBitwiseOperators<int, int, int>, IComparable, IComparable<int>, IComparisonOperators<int, int>, IConvertible, IDecrementOperators<int>, IDivisionOperators<int, int, int>, IEqualityOperators<int, int>, IEquatable<int>, IFormattable, IIncrementOperators<int>, IMinMaxValue<int>, IModulusOperators<int, int, int>, IMultiplicativeIdentity<int, int>, IMultiplyOperators<int, int, int>, INumber<int>, INumberBase<int>, IParsable<int>, IShiftOperators<int, int>, ISignedNumber<int>, ISpanFormattable, ISpanParsable<int>, ISubtractionOperators<int, int, int>, IUnaryNegationOperators<int, int>, IUnaryPlusOperators<int, int> {
++        static int System.Numerics.INumberBase<System.Int32>.Radix { get; }
+-        public static int CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static int CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static int CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(int value);
++        public static bool IsOddInteger(int value);
++        public static bool IsPositive(int value);
+-        long IBinaryInteger<int>.GetShortestBitLength();
++        int IBinaryInteger<int>.GetShortestBitLength();
++        bool IBinaryInteger<int>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static int INumber<int>.MaxNumber(int x, int y);
++        static int INumber<int>.MinNumber(int x, int y);
++        static bool INumberBase<int>.IsCanonical(int value);
++        static bool INumberBase<int>.IsComplexNumber(int value);
++        static bool INumberBase<int>.IsFinite(int value);
++        static bool INumberBase<int>.IsImaginaryNumber(int value);
++        static bool INumberBase<int>.IsInfinity(int value);
++        static bool INumberBase<int>.IsInteger(int value);
++        static bool INumberBase<int>.IsNaN(int value);
++        static bool INumberBase<int>.IsNegativeInfinity(int value);
++        static bool INumberBase<int>.IsNormal(int value);
++        static bool INumberBase<int>.IsPositiveInfinity(int value);
++        static bool INumberBase<int>.IsRealNumber(int value);
++        static bool INumberBase<int>.IsSubnormal(int value);
++        static bool INumberBase<int>.IsZero(int value);
++        static int INumberBase<int>.MaxMagnitudeNumber(int x, int y);
++        static int INumberBase<int>.MinMagnitudeNumber(int x, int y);
++        static bool INumberBase<int>.TryConvertFromChecked<TOther>(TOther value, out int result);
++        static bool INumberBase<int>.TryConvertFromSaturating<TOther>(TOther value, out int result);
++        static bool INumberBase<int>.TryConvertFromTruncating<TOther>(TOther value, out int result);
++        static bool INumberBase<int>.TryConvertToChecked<TOther>(int value, out TOther result);
++        static bool INumberBase<int>.TryConvertToSaturating<TOther>(int value, out TOther result);
++        static bool INumberBase<int>.TryConvertToTruncating<TOther>(int value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out int result) where TOther : INumber<TOther>;
+     }
+     public readonly struct Int64 : IAdditionOperators<long, long, long>, IAdditiveIdentity<long, long>, IBinaryInteger<long>, IBinaryNumber<long>, IBitwiseOperators<long, long, long>, IComparable, IComparable<long>, IComparisonOperators<long, long>, IConvertible, IDecrementOperators<long>, IDivisionOperators<long, long, long>, IEqualityOperators<long, long>, IEquatable<long>, IFormattable, IIncrementOperators<long>, IMinMaxValue<long>, IModulusOperators<long, long, long>, IMultiplicativeIdentity<long, long>, IMultiplyOperators<long, long, long>, INumber<long>, INumberBase<long>, IParsable<long>, IShiftOperators<long, long>, ISignedNumber<long>, ISpanFormattable, ISpanParsable<long>, ISubtractionOperators<long, long, long>, IUnaryNegationOperators<long, long>, IUnaryPlusOperators<long, long> {
++        static int System.Numerics.INumberBase<System.Int64>.Radix { get; }
+-        public static long CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static long CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static long CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(long value);
++        public static bool IsOddInteger(long value);
++        public static bool IsPositive(long value);
+-        long IBinaryInteger<long>.GetShortestBitLength();
++        int IBinaryInteger<long>.GetShortestBitLength();
++        bool IBinaryInteger<long>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static long INumber<long>.MaxNumber(long x, long y);
++        static long INumber<long>.MinNumber(long x, long y);
++        static bool INumberBase<long>.IsCanonical(long value);
++        static bool INumberBase<long>.IsComplexNumber(long value);
++        static bool INumberBase<long>.IsFinite(long value);
++        static bool INumberBase<long>.IsImaginaryNumber(long value);
++        static bool INumberBase<long>.IsInfinity(long value);
++        static bool INumberBase<long>.IsInteger(long value);
++        static bool INumberBase<long>.IsNaN(long value);
++        static bool INumberBase<long>.IsNegativeInfinity(long value);
++        static bool INumberBase<long>.IsNormal(long value);
++        static bool INumberBase<long>.IsPositiveInfinity(long value);
++        static bool INumberBase<long>.IsRealNumber(long value);
++        static bool INumberBase<long>.IsSubnormal(long value);
++        static bool INumberBase<long>.IsZero(long value);
++        static long INumberBase<long>.MaxMagnitudeNumber(long x, long y);
++        static long INumberBase<long>.MinMagnitudeNumber(long x, long y);
++        static bool INumberBase<long>.TryConvertFromChecked<TOther>(TOther value, out long result);
++        static bool INumberBase<long>.TryConvertFromSaturating<TOther>(TOther value, out long result);
++        static bool INumberBase<long>.TryConvertFromTruncating<TOther>(TOther value, out long result);
++        static bool INumberBase<long>.TryConvertToChecked<TOther>(long value, out TOther result);
++        static bool INumberBase<long>.TryConvertToSaturating<TOther>(long value, out TOther result);
++        static bool INumberBase<long>.TryConvertToTruncating<TOther>(long value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out long result) where TOther : INumber<TOther>;
+     }
+     public readonly struct IntPtr : IAdditionOperators<IntPtr, IntPtr, IntPtr>, IAdditiveIdentity<IntPtr, IntPtr>, IBinaryInteger<IntPtr>, IBinaryNumber<IntPtr>, IBitwiseOperators<IntPtr, IntPtr, IntPtr>, IComparable, IComparable<IntPtr>, IComparisonOperators<IntPtr, IntPtr>, IDecrementOperators<IntPtr>, IDivisionOperators<IntPtr, IntPtr, IntPtr>, IEqualityOperators<IntPtr, IntPtr>, IEquatable<IntPtr>, IFormattable, IIncrementOperators<IntPtr>, IMinMaxValue<IntPtr>, IModulusOperators<IntPtr, IntPtr, IntPtr>, IMultiplicativeIdentity<IntPtr, IntPtr>, IMultiplyOperators<IntPtr, IntPtr, IntPtr>, INumber<IntPtr>, INumberBase<IntPtr>, IParsable<IntPtr>, ISerializable, IShiftOperators<IntPtr, IntPtr>, ISignedNumber<IntPtr>, ISpanFormattable, ISpanParsable<IntPtr>, ISubtractionOperators<IntPtr, IntPtr, IntPtr>, IUnaryNegationOperators<IntPtr, IntPtr>, IUnaryPlusOperators<IntPtr, IntPtr> {
++        static int System.Numerics.INumberBase<nint>.Radix { get; }
++        public static IntPtr Abs(IntPtr value);
++        public static IntPtr Clamp(IntPtr value, IntPtr min, IntPtr max);
++        public static IntPtr CopySign(IntPtr value, IntPtr sign);
++        public static (IntPtr Quotient, IntPtr Remainder) DivRem(IntPtr left, IntPtr right);
++        public static bool IsEvenInteger(IntPtr value);
++        public static bool IsNegative(IntPtr value);
++        public static bool IsOddInteger(IntPtr value);
++        public static bool IsPositive(IntPtr value);
++        public static bool IsPow2(IntPtr value);
++        public static IntPtr LeadingZeroCount(IntPtr value);
++        public static IntPtr Log2(IntPtr value);
++        public static IntPtr Max(IntPtr x, IntPtr y);
++        public static IntPtr MaxMagnitude(IntPtr x, IntPtr y);
++        public static IntPtr Min(IntPtr x, IntPtr y);
++        public static IntPtr MinMagnitude(IntPtr x, IntPtr y);
++        public static IntPtr PopCount(IntPtr value);
++        public static IntPtr RotateLeft(IntPtr value, int rotateAmount);
++        public static IntPtr RotateRight(IntPtr value, int rotateAmount);
++        public static int Sign(IntPtr value);
+-        static (IntPtr Quotient, IntPtr Remainder) IBinaryInteger<IntPtr>.DivRem(IntPtr left, IntPtr right);
+-        long IBinaryInteger<IntPtr>.GetShortestBitLength();
++        int IBinaryInteger<IntPtr>.GetShortestBitLength();
+-        static IntPtr IBinaryInteger<IntPtr>.LeadingZeroCount(IntPtr value);
+-        static IntPtr IBinaryInteger<IntPtr>.PopCount(IntPtr value);
+-        static IntPtr IBinaryInteger<IntPtr>.RotateLeft(IntPtr value, int rotateAmount);
+-        static IntPtr IBinaryInteger<IntPtr>.RotateRight(IntPtr value, int rotateAmount);
+-        static IntPtr IBinaryInteger<IntPtr>.TrailingZeroCount(IntPtr value);
++        bool IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static bool IBinaryNumber<IntPtr>.IsPow2(IntPtr value);
+-        static IntPtr IBinaryNumber<IntPtr>.Log2(IntPtr value);
+-        static IntPtr INumber<IntPtr>.Abs(IntPtr value);
+-        static IntPtr INumber<IntPtr>.Clamp(IntPtr value, IntPtr min, IntPtr max);
+-        static IntPtr INumber<IntPtr>.CopySign(IntPtr value, IntPtr sign);
+-        static IntPtr INumber<IntPtr>.CreateChecked<TOther>(TOther value);
+-        static IntPtr INumber<IntPtr>.CreateSaturating<TOther>(TOther value);
+-        static IntPtr INumber<IntPtr>.CreateTruncating<TOther>(TOther value);
+-        static bool INumber<IntPtr>.IsNegative(IntPtr value);
+-        static IntPtr INumber<IntPtr>.Max(IntPtr x, IntPtr y);
+-        static IntPtr INumber<IntPtr>.MaxMagnitude(IntPtr x, IntPtr y);
++        static IntPtr INumber<IntPtr>.MaxNumber(IntPtr x, IntPtr y);
+-        static IntPtr INumber<IntPtr>.Min(IntPtr x, IntPtr y);
+-        static IntPtr INumber<IntPtr>.MinMagnitude(IntPtr x, IntPtr y);
++        static IntPtr INumber<IntPtr>.MinNumber(IntPtr x, IntPtr y);
+-        static int INumber<IntPtr>.Sign(IntPtr value);
+-        static bool INumber<IntPtr>.TryCreate<TOther>(TOther value, out IntPtr result);
++        static bool INumberBase<IntPtr>.IsCanonical(IntPtr value);
++        static bool INumberBase<IntPtr>.IsComplexNumber(IntPtr value);
++        static bool INumberBase<IntPtr>.IsFinite(IntPtr value);
++        static bool INumberBase<IntPtr>.IsImaginaryNumber(IntPtr value);
++        static bool INumberBase<IntPtr>.IsInfinity(IntPtr value);
++        static bool INumberBase<IntPtr>.IsInteger(IntPtr value);
++        static bool INumberBase<IntPtr>.IsNaN(IntPtr value);
++        static bool INumberBase<IntPtr>.IsNegativeInfinity(IntPtr value);
++        static bool INumberBase<IntPtr>.IsNormal(IntPtr value);
++        static bool INumberBase<IntPtr>.IsPositiveInfinity(IntPtr value);
++        static bool INumberBase<IntPtr>.IsRealNumber(IntPtr value);
++        static bool INumberBase<IntPtr>.IsSubnormal(IntPtr value);
++        static bool INumberBase<IntPtr>.IsZero(IntPtr value);
++        static IntPtr INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr x, IntPtr y);
++        static IntPtr INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr x, IntPtr y);
++        static bool INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther value, out IntPtr result);
++        static bool INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther value, out IntPtr result);
++        static bool INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther value, out IntPtr result);
++        static bool INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr value, out TOther result);
++        static bool INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr value, out TOther result);
++        static bool INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr value, out TOther result);
++        public static IntPtr TrailingZeroCount(IntPtr value);
+     }
+     public struct RuntimeFieldHandle : IEquatable<RuntimeFieldHandle>, ISerializable {
++        public static RuntimeFieldHandle FromIntPtr(IntPtr value);
++        public static IntPtr ToIntPtr(RuntimeFieldHandle value);
+     }
+     public struct RuntimeMethodHandle : IEquatable<RuntimeMethodHandle>, ISerializable {
++        public static RuntimeMethodHandle FromIntPtr(IntPtr value);
++        public static IntPtr ToIntPtr(RuntimeMethodHandle value);
+     }
+     public struct RuntimeTypeHandle : IEquatable<RuntimeTypeHandle>, ISerializable {
++        public static RuntimeTypeHandle FromIntPtr(IntPtr value);
++        public static IntPtr ToIntPtr(RuntimeTypeHandle value);
+     }
+     public readonly struct SByte : IAdditionOperators<sbyte, sbyte, sbyte>, IAdditiveIdentity<sbyte, sbyte>, IBinaryInteger<sbyte>, IBinaryNumber<sbyte>, IBitwiseOperators<sbyte, sbyte, sbyte>, IComparable, IComparable<sbyte>, IComparisonOperators<sbyte, sbyte>, IConvertible, IDecrementOperators<sbyte>, IDivisionOperators<sbyte, sbyte, sbyte>, IEqualityOperators<sbyte, sbyte>, IEquatable<sbyte>, IFormattable, IIncrementOperators<sbyte>, IMinMaxValue<sbyte>, IModulusOperators<sbyte, sbyte, sbyte>, IMultiplicativeIdentity<sbyte, sbyte>, IMultiplyOperators<sbyte, sbyte, sbyte>, INumber<sbyte>, INumberBase<sbyte>, IParsable<sbyte>, IShiftOperators<sbyte, sbyte>, ISignedNumber<sbyte>, ISpanFormattable, ISpanParsable<sbyte>, ISubtractionOperators<sbyte, sbyte, sbyte>, IUnaryNegationOperators<sbyte, sbyte>, IUnaryPlusOperators<sbyte, sbyte> {
++        static int System.Numerics.INumberBase<System.SByte>.Radix { get; }
+-        public static sbyte CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static sbyte CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static sbyte CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(sbyte value);
++        public static bool IsOddInteger(sbyte value);
++        public static bool IsPositive(sbyte value);
+-        long IBinaryInteger<sbyte>.GetShortestBitLength();
++        int IBinaryInteger<sbyte>.GetShortestBitLength();
++        bool IBinaryInteger<sbyte>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        static sbyte INumber<sbyte>.MaxNumber(sbyte x, sbyte y);
++        static sbyte INumber<sbyte>.MinNumber(sbyte x, sbyte y);
++        static bool INumberBase<sbyte>.IsCanonical(sbyte value);
++        static bool INumberBase<sbyte>.IsComplexNumber(sbyte value);
++        static bool INumberBase<sbyte>.IsFinite(sbyte value);
++        static bool INumberBase<sbyte>.IsImaginaryNumber(sbyte value);
++        static bool INumberBase<sbyte>.IsInfinity(sbyte value);
++        static bool INumberBase<sbyte>.IsInteger(sbyte value);
++        static bool INumberBase<sbyte>.IsNaN(sbyte value);
++        static bool INumberBase<sbyte>.IsNegativeInfinity(sbyte value);
++        static bool INumberBase<sbyte>.IsNormal(sbyte value);
++        static bool INumberBase<sbyte>.IsPositiveInfinity(sbyte value);
++        static bool INumberBase<sbyte>.IsRealNumber(sbyte value);
++        static bool INumberBase<sbyte>.IsSubnormal(sbyte value);
++        static bool INumberBase<sbyte>.IsZero(sbyte value);
++        static sbyte INumberBase<sbyte>.MaxMagnitudeNumber(sbyte x, sbyte y);
++        static sbyte INumberBase<sbyte>.MinMagnitudeNumber(sbyte x, sbyte y);
++        static bool INumberBase<sbyte>.TryConvertFromChecked<TOther>(TOther value, out sbyte result);
++        static bool INumberBase<sbyte>.TryConvertFromSaturating<TOther>(TOther value, out sbyte result);
++        static bool INumberBase<sbyte>.TryConvertFromTruncating<TOther>(TOther value, out sbyte result);
++        static bool INumberBase<sbyte>.TryConvertToChecked<TOther>(sbyte value, out TOther result);
++        static bool INumberBase<sbyte>.TryConvertToSaturating<TOther>(sbyte value, out TOther result);
++        static bool INumberBase<sbyte>.TryConvertToTruncating<TOther>(sbyte value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out sbyte result) where TOther : INumber<TOther>;
+     }
+     public readonly struct Single : IAdditionOperators<float, float, float>, IAdditiveIdentity<float, float>, IBinaryFloatingPointIeee754<float>, IBinaryNumber<float>, IBitwiseOperators<float, float, float>, IComparable, IComparable<float>, IComparisonOperators<float, float>, IConvertible, IDecrementOperators<float>, IDivisionOperators<float, float, float>, IEqualityOperators<float, float>, IEquatable<float>, IExponentialFunctions<float>, IFloatingPoint<float>, IFloatingPointIeee754<float>, IFormattable, IHyperbolicFunctions<float>, IIncrementOperators<float>, ILogarithmicFunctions<float>, IMinMaxValue<float>, IModulusOperators<float, float, float>, IMultiplicativeIdentity<float, float>, IMultiplyOperators<float, float, float>, INumber<float>, INumberBase<float>, IParsable<float>, IPowerFunctions<float>, IRootFunctions<float>, ISignedNumber<float>, ISpanFormattable, ISpanParsable<float>, ISubtractionOperators<float, float, float>, ITrigonometricFunctions<float>, IUnaryNegationOperators<float, float>, IUnaryPlusOperators<float, float> {
++        static int System.Numerics.INumberBase<System.Single>.Radix { get; }
+-        public static float CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static float CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static float CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static float Exp10(float x);
++        public static float Exp10M1(float x);
++        public static float Exp2(float x);
++        public static float Exp2M1(float x);
++        public static float ExpM1(float x);
++        public static bool IsEvenInteger(float value);
++        public static bool IsInteger(float value);
++        public static bool IsOddInteger(float value);
++        public static bool IsPositive(float value);
++        public static bool IsRealNumber(float value);
++        public static float Log10P1(float x);
++        public static float Log2P1(float x);
++        public static float LogP1(float x);
++        public static float MaxMagnitudeNumber(float x, float y);
++        public static float MaxNumber(float x, float y);
++        public static float MinMagnitudeNumber(float x, float y);
++        public static float MinNumber(float x, float y);
+-        long IFloatingPoint<float>.GetExponentShortestBitLength();
++        int IFloatingPoint<float>.GetExponentShortestBitLength();
+-        long IFloatingPoint<float>.GetSignificandBitLength();
++        int IFloatingPoint<float>.GetSignificandBitLength();
++        bool IFloatingPoint<float>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IFloatingPoint<float>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten);
++        static bool INumberBase<float>.IsCanonical(float value);
++        static bool INumberBase<float>.IsComplexNumber(float value);
++        static bool INumberBase<float>.IsImaginaryNumber(float value);
++        static bool INumberBase<float>.IsZero(float value);
++        static bool INumberBase<float>.TryConvertFromChecked<TOther>(TOther value, out float result);
++        static bool INumberBase<float>.TryConvertFromSaturating<TOther>(TOther value, out float result);
++        static bool INumberBase<float>.TryConvertFromTruncating<TOther>(TOther value, out float result);
++        static bool INumberBase<float>.TryConvertToChecked<TOther>(float value, out TOther result);
++        static bool INumberBase<float>.TryConvertToSaturating<TOther>(float value, out TOther result);
++        static bool INumberBase<float>.TryConvertToTruncating<TOther>(float value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out float result) where TOther : INumber<TOther>;
+     }
+-    public readonly struct TimeOnly : IComparable, IComparable<TimeOnly>, IComparisonOperators<TimeOnly, TimeOnly>, IEqualityOperators<TimeOnly, TimeOnly>, IEquatable<TimeOnly>, IFormattable, IMinMaxValue<TimeOnly>, IParsable<TimeOnly>, ISpanFormattable, ISpanParsable<TimeOnly>, ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan> {
++    public readonly struct TimeOnly : IComparable, IComparable<TimeOnly>, IEquatable<TimeOnly>, IFormattable, IParsable<TimeOnly>, ISpanFormattable, ISpanParsable<TimeOnly> {
+-        static TimeSpan ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan>.operator checked -(TimeOnly left, TimeOnly right);
+     }
+-    public readonly struct TimeSpan : IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>, IAdditiveIdentity<TimeSpan, TimeSpan>, IComparable, IComparable<TimeSpan>, IComparisonOperators<TimeSpan, TimeSpan>, IDivisionOperators<TimeSpan, double, TimeSpan>, IDivisionOperators<TimeSpan, TimeSpan, double>, IEqualityOperators<TimeSpan, TimeSpan>, IEquatable<TimeSpan>, IFormattable, IMinMaxValue<TimeSpan>, IMultiplicativeIdentity<TimeSpan, double>, IMultiplyOperators<TimeSpan, double, TimeSpan>, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>, IUnaryNegationOperators<TimeSpan, TimeSpan>, IUnaryPlusOperators<TimeSpan, TimeSpan> {
++    public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan> {
+-        static TimeSpan System.Numerics.IAdditiveIdentity<System.TimeSpan,System.TimeSpan>.AdditiveIdentity { get; }
+-        static TimeSpan System.Numerics.IMinMaxValue<System.TimeSpan>.MaxValue { get; }
+-        static TimeSpan System.Numerics.IMinMaxValue<System.TimeSpan>.MinValue { get; }
+-        static double System.Numerics.IMultiplicativeIdentity<System.TimeSpan,System.Double>.MultiplicativeIdentity { get; }
+-        static TimeSpan IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>.operator checked +(TimeSpan left, TimeSpan right);
+-        static TimeSpan IDivisionOperators<TimeSpan, double, TimeSpan>.operator checked /(TimeSpan left, double right);
+-        static double IDivisionOperators<TimeSpan, TimeSpan, double>.operator checked /(TimeSpan left, TimeSpan right);
+-        static TimeSpan IMultiplyOperators<TimeSpan, double, TimeSpan>.operator checked *(TimeSpan left, double right);
+-        static TimeSpan ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>.operator checked -(TimeSpan left, TimeSpan right);
+-        static TimeSpan IUnaryNegationOperators<TimeSpan, TimeSpan>.operator checked -(TimeSpan value);
+     }
++    public readonly struct UInt128 : IAdditionOperators<UInt128, UInt128, UInt128>, IAdditiveIdentity<UInt128, UInt128>, IBinaryInteger<UInt128>, IBinaryNumber<UInt128>, IBitwiseOperators<UInt128, UInt128, UInt128>, IComparable, IComparable<UInt128>, IComparisonOperators<UInt128, UInt128>, IDecrementOperators<UInt128>, IDivisionOperators<UInt128, UInt128, UInt128>, IEqualityOperators<UInt128, UInt128>, IEquatable<UInt128>, IFormattable, IIncrementOperators<UInt128>, IMinMaxValue<UInt128>, IModulusOperators<UInt128, UInt128, UInt128>, IMultiplicativeIdentity<UInt128, UInt128>, IMultiplyOperators<UInt128, UInt128, UInt128>, INumber<UInt128>, INumberBase<UInt128>, IParsable<UInt128>, IShiftOperators<UInt128, UInt128>, ISpanFormattable, ISpanParsable<UInt128>, ISubtractionOperators<UInt128, UInt128, UInt128>, IUnaryNegationOperators<UInt128, UInt128>, IUnaryPlusOperators<UInt128, UInt128>, IUnsignedNumber<UInt128> {
++        public UInt128(ulong upper, ulong lower);
++        public static UInt128 MaxValue { get; }
++        public static UInt128 MinValue { get; }
++        public static UInt128 One { get; }
++        static UInt128 System.Numerics.IAdditiveIdentity<System.UInt128,System.UInt128>.AdditiveIdentity { get; }
++        static UInt128 System.Numerics.IMultiplicativeIdentity<System.UInt128,System.UInt128>.MultiplicativeIdentity { get; }
++        static int System.Numerics.INumberBase<System.UInt128>.Radix { get; }
++        public static UInt128 Zero { get; }
++        public static UInt128 Clamp(UInt128 value, UInt128 min, UInt128 max);
++        public int CompareTo(object? value);
++        public int CompareTo(UInt128 value);
++        public static (UInt128 Quotient, UInt128 Remainder) DivRem(UInt128 left, UInt128 right);
++        public override bool Equals(object? obj);
++        public bool Equals(UInt128 other);
++        public override int GetHashCode();
++        public static bool IsEvenInteger(UInt128 value);
++        public static bool IsOddInteger(UInt128 value);
++        public static bool IsPow2(UInt128 value);
++        public static UInt128 LeadingZeroCount(UInt128 value);
++        public static UInt128 Log2(UInt128 value);
++        public static UInt128 Max(UInt128 x, UInt128 y);
++        public static UInt128 Min(UInt128 x, UInt128 y);
++        public static UInt128 operator +(UInt128 left, UInt128 right);
++        public static UInt128 operator &(UInt128 left, UInt128 right);
++        public static UInt128 operator |(UInt128 left, UInt128 right);
++        public static UInt128 operator checked +(UInt128 left, UInt128 right);
++        public static UInt128 operator checked --(UInt128 value);
++        public static UInt128 operator checked /(UInt128 left, UInt128 right);
++        public static explicit operator checked UInt128 (double value);
++        public static explicit operator checked UInt128 (short value);
++        public static explicit operator checked UInt128 (int value);
++        public static explicit operator checked UInt128 (long value);
++        public static explicit operator checked UInt128 (nint value);
++        public static explicit operator checked UInt128 (sbyte value);
++        public static explicit operator checked UInt128 (float value);
++        public static explicit operator checked byte (UInt128 value);
++        public static explicit operator checked char (UInt128 value);
++        public static explicit operator checked short (UInt128 value);
++        public static explicit operator checked int (UInt128 value);
++        public static explicit operator checked long (UInt128 value);
++        public static explicit operator checked Int128 (UInt128 value);
++        public static explicit operator checked nint (UInt128 value);
++        public static explicit operator checked sbyte (UInt128 value);
++        public static explicit operator checked ushort (UInt128 value);
++        public static explicit operator checked uint (UInt128 value);
++        public static explicit operator checked ulong (UInt128 value);
++        public static explicit operator checked nuint (UInt128 value);
++        public static UInt128 operator checked ++(UInt128 value);
++        public static UInt128 operator checked *(UInt128 left, UInt128 right);
++        public static UInt128 operator checked -(UInt128 left, UInt128 right);
++        public static UInt128 operator checked -(UInt128 value);
++        public static UInt128 operator --(UInt128 value);
++        public static UInt128 operator /(UInt128 left, UInt128 right);
++        public static bool operator ==(UInt128 left, UInt128 right);
++        public static UInt128 operator ^(UInt128 left, UInt128 right);
++        public static explicit operator UInt128 (decimal value);
++        public static explicit operator UInt128 (double value);
++        public static explicit operator UInt128 (short value);
++        public static explicit operator UInt128 (int value);
++        public static explicit operator UInt128 (long value);
++        public static explicit operator UInt128 (nint value);
++        public static explicit operator UInt128 (sbyte value);
++        public static explicit operator UInt128 (float value);
++        public static explicit operator byte (UInt128 value);
++        public static explicit operator char (UInt128 value);
++        public static explicit operator decimal (UInt128 value);
++        public static explicit operator double (UInt128 value);
++        public static explicit operator Half (UInt128 value);
++        public static explicit operator Int128 (UInt128 value);
++        public static explicit operator short (UInt128 value);
++        public static explicit operator int (UInt128 value);
++        public static explicit operator long (UInt128 value);
++        public static explicit operator nint (UInt128 value);
++        public static explicit operator sbyte (UInt128 value);
++        public static explicit operator float (UInt128 value);
++        public static explicit operator ushort (UInt128 value);
++        public static explicit operator uint (UInt128 value);
++        public static explicit operator ulong (UInt128 value);
++        public static explicit operator nuint (UInt128 value);
++        public static bool operator >(UInt128 left, UInt128 right);
++        public static bool operator >=(UInt128 left, UInt128 right);
++        public static implicit operator UInt128 (byte value);
++        public static implicit operator UInt128 (char value);
++        public static implicit operator UInt128 (ushort value);
++        public static implicit operator UInt128 (uint value);
++        public static implicit operator UInt128 (ulong value);
++        public static implicit operator UInt128 (nuint value);
++        public static UInt128 operator ++(UInt128 value);
++        public static bool operator !=(UInt128 left, UInt128 right);
++        public static UInt128 operator <<(UInt128 value, int shiftAmount);
++        public static bool operator <(UInt128 left, UInt128 right);
++        public static bool operator <=(UInt128 left, UInt128 right);
++        public static UInt128 operator %(UInt128 left, UInt128 right);
++        public static UInt128 operator *(UInt128 left, UInt128 right);
++        public static UInt128 operator ~(UInt128 value);
++        public static UInt128 operator >>(UInt128 value, int shiftAmount);
++        public static UInt128 operator -(UInt128 left, UInt128 right);
++        public static UInt128 operator -(UInt128 value);
++        public static UInt128 operator +(UInt128 value);
++        public static UInt128 operator >>>(UInt128 value, int shiftAmount);
++        public static UInt128 Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null);
++        public static UInt128 Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
++        public static UInt128 Parse(string s);
++        public static UInt128 Parse(string s, NumberStyles style);
++        public static UInt128 Parse(string s, NumberStyles style, IFormatProvider? provider);
++        public static UInt128 Parse(string s, IFormatProvider? provider);
++        public static UInt128 PopCount(UInt128 value);
++        public static UInt128 RotateLeft(UInt128 value, int rotateAmount);
++        public static UInt128 RotateRight(UInt128 value, int rotateAmount);
++        public static int Sign(UInt128 value);
++        int IBinaryInteger<UInt128>.GetByteCount();
++        int IBinaryInteger<UInt128>.GetShortestBitLength();
++        bool IBinaryInteger<UInt128>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
++        bool IBinaryInteger<UInt128>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten);
++        static UInt128 INumber<UInt128>.CopySign(UInt128 value, UInt128 sign);
++        static UInt128 INumber<UInt128>.MaxNumber(UInt128 x, UInt128 y);
++        static UInt128 INumber<UInt128>.MinNumber(UInt128 x, UInt128 y);
++        static UInt128 INumberBase<UInt128>.Abs(UInt128 value);
++        static bool INumberBase<UInt128>.IsCanonical(UInt128 value);
++        static bool INumberBase<UInt128>.IsComplexNumber(UInt128 value);
++        static bool INumberBase<UInt128>.IsFinite(UInt128 value);
++        static bool INumberBase<UInt128>.IsImaginaryNumber(UInt128 value);
++        static bool INumberBase<UInt128>.IsInfinity(UInt128 value);
++        static bool INumberBase<UInt128>.IsInteger(UInt128 value);
++        static bool INumberBase<UInt128>.IsNaN(UInt128 value);
++        static bool INumberBase<UInt128>.IsNegative(UInt128 value);
++        static bool INumberBase<UInt128>.IsNegativeInfinity(UInt128 value);
++        static bool INumberBase<UInt128>.IsNormal(UInt128 value);
++        static bool INumberBase<UInt128>.IsPositive(UInt128 value);
++        static bool INumberBase<UInt128>.IsPositiveInfinity(UInt128 value);
++        static bool INumberBase<UInt128>.IsRealNumber(UInt128 value);
++        static bool INumberBase<UInt128>.IsSubnormal(UInt128 value);
++        static bool INumberBase<UInt128>.IsZero(UInt128 value);
++        static UInt128 INumberBase<UInt128>.MaxMagnitude(UInt128 x, UInt128 y);
++        static UInt128 INumberBase<UInt128>.MaxMagnitudeNumber(UInt128 x, UInt128 y);
++        static UInt128 INumberBase<UInt128>.MinMagnitude(UInt128 x, UInt128 y);
++        static UInt128 INumberBase<UInt128>.MinMagnitudeNumber(UInt128 x, UInt128 y);
++        static bool INumberBase<UInt128>.TryConvertFromChecked<TOther>(TOther value, out UInt128 result);
++        static bool INumberBase<UInt128>.TryConvertFromSaturating<TOther>(TOther value, out UInt128 result);
++        static bool INumberBase<UInt128>.TryConvertFromTruncating<TOther>(TOther value, out UInt128 result);
++        static bool INumberBase<UInt128>.TryConvertToChecked<TOther>(UInt128 value, out TOther result);
++        static bool INumberBase<UInt128>.TryConvertToSaturating<TOther>(UInt128 value, out TOther result);
++        static bool INumberBase<UInt128>.TryConvertToTruncating<TOther>(UInt128 value, out TOther result);
++        public override string ToString();
++        public string ToString(IFormatProvider? provider);
++        public string ToString(string? format);
++        public string ToString(string? format, IFormatProvider? provider);
++        public static UInt128 TrailingZeroCount(UInt128 value);
++        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null);
++        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out UInt128 result);
++        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out UInt128 result);
++        public static bool TryParse(ReadOnlySpan<char> s, out UInt128 result);
++        public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out UInt128 result);
++        public static bool TryParse(string? s, IFormatProvider? provider, out UInt128 result);
++        public static bool TryParse(string? s, out UInt128 result);
++    }
+     public readonly struct UInt16 : IAdditionOperators<ushort, ushort, ushort>, IAdditiveIdentity<ushort, ushort>, IBinaryInteger<ushort>, IBinaryNumber<ushort>, IBitwiseOperators<ushort, ushort, ushort>, IComparable, IComparable<ushort>, IComparisonOperators<ushort, ushort>, IConvertible, IDecrementOperators<ushort>, IDivisionOperators<ushort, ushort, ushort>, IEqualityOperators<ushort, ushort>, IEquatable<ushort>, IFormattable, IIncrementOperators<ushort>, IMinMaxValue<ushort>, IModulusOperators<ushort, ushort, ushort>, IMultiplicativeIdentity<ushort, ushort>, IMultiplyOperators<ushort, ushort, ushort>, INumber<ushort>, INumberBase<ushort>, IParsable<ushort>, IShiftOperators<ushort, ushort>, ISpanFormattable, ISpanParsable<ushort>, ISubtractionOperators<ushort, ushort, ushort>, IUnaryNegationOperators<ushort, ushort>, IUnaryPlusOperators<ushort, ushort>, IUnsignedNumber<ushort> {
++        static int System.Numerics.INumberBase<System.UInt16>.Radix { get; }
+-        public static ushort CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static ushort CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static ushort CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(ushort value);
++        public static bool IsOddInteger(ushort value);
+-        long IBinaryInteger<ushort>.GetShortestBitLength();
++        int IBinaryInteger<ushort>.GetShortestBitLength();
++        bool IBinaryInteger<ushort>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static ushort INumber<ushort>.Abs(ushort value);
+-        static bool INumber<ushort>.IsNegative(ushort value);
+-        static ushort INumber<ushort>.MaxMagnitude(ushort x, ushort y);
++        static ushort INumber<ushort>.MaxNumber(ushort x, ushort y);
+-        static ushort INumber<ushort>.MinMagnitude(ushort x, ushort y);
++        static ushort INumber<ushort>.MinNumber(ushort x, ushort y);
++        static ushort INumberBase<ushort>.Abs(ushort value);
++        static bool INumberBase<ushort>.IsCanonical(ushort value);
++        static bool INumberBase<ushort>.IsComplexNumber(ushort value);
++        static bool INumberBase<ushort>.IsFinite(ushort value);
++        static bool INumberBase<ushort>.IsImaginaryNumber(ushort value);
++        static bool INumberBase<ushort>.IsInfinity(ushort value);
++        static bool INumberBase<ushort>.IsInteger(ushort value);
++        static bool INumberBase<ushort>.IsNaN(ushort value);
++        static bool INumberBase<ushort>.IsNegative(ushort value);
++        static bool INumberBase<ushort>.IsNegativeInfinity(ushort value);
++        static bool INumberBase<ushort>.IsNormal(ushort value);
++        static bool INumberBase<ushort>.IsPositive(ushort value);
++        static bool INumberBase<ushort>.IsPositiveInfinity(ushort value);
++        static bool INumberBase<ushort>.IsRealNumber(ushort value);
++        static bool INumberBase<ushort>.IsSubnormal(ushort value);
++        static bool INumberBase<ushort>.IsZero(ushort value);
++        static ushort INumberBase<ushort>.MaxMagnitude(ushort x, ushort y);
++        static ushort INumberBase<ushort>.MaxMagnitudeNumber(ushort x, ushort y);
++        static ushort INumberBase<ushort>.MinMagnitude(ushort x, ushort y);
++        static ushort INumberBase<ushort>.MinMagnitudeNumber(ushort x, ushort y);
++        static bool INumberBase<ushort>.TryConvertFromChecked<TOther>(TOther value, out ushort result);
++        static bool INumberBase<ushort>.TryConvertFromSaturating<TOther>(TOther value, out ushort result);
++        static bool INumberBase<ushort>.TryConvertFromTruncating<TOther>(TOther value, out ushort result);
++        static bool INumberBase<ushort>.TryConvertToChecked<TOther>(ushort value, out TOther result);
++        static bool INumberBase<ushort>.TryConvertToSaturating<TOther>(ushort value, out TOther result);
++        static bool INumberBase<ushort>.TryConvertToTruncating<TOther>(ushort value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out ushort result) where TOther : INumber<TOther>;
+     }
+     public readonly struct UInt32 : IAdditionOperators<uint, uint, uint>, IAdditiveIdentity<uint, uint>, IBinaryInteger<uint>, IBinaryNumber<uint>, IBitwiseOperators<uint, uint, uint>, IComparable, IComparable<uint>, IComparisonOperators<uint, uint>, IConvertible, IDecrementOperators<uint>, IDivisionOperators<uint, uint, uint>, IEqualityOperators<uint, uint>, IEquatable<uint>, IFormattable, IIncrementOperators<uint>, IMinMaxValue<uint>, IModulusOperators<uint, uint, uint>, IMultiplicativeIdentity<uint, uint>, IMultiplyOperators<uint, uint, uint>, INumber<uint>, INumberBase<uint>, IParsable<uint>, IShiftOperators<uint, uint>, ISpanFormattable, ISpanParsable<uint>, ISubtractionOperators<uint, uint, uint>, IUnaryNegationOperators<uint, uint>, IUnaryPlusOperators<uint, uint>, IUnsignedNumber<uint> {
++        static int System.Numerics.INumberBase<System.UInt32>.Radix { get; }
+-        public static uint CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static uint CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static uint CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(uint value);
++        public static bool IsOddInteger(uint value);
+-        long IBinaryInteger<uint>.GetShortestBitLength();
++        int IBinaryInteger<uint>.GetShortestBitLength();
++        bool IBinaryInteger<uint>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static uint INumber<uint>.Abs(uint value);
+-        static bool INumber<uint>.IsNegative(uint value);
+-        static uint INumber<uint>.MaxMagnitude(uint x, uint y);
++        static uint INumber<uint>.MaxNumber(uint x, uint y);
+-        static uint INumber<uint>.MinMagnitude(uint x, uint y);
++        static uint INumber<uint>.MinNumber(uint x, uint y);
++        static uint INumberBase<uint>.Abs(uint value);
++        static bool INumberBase<uint>.IsCanonical(uint value);
++        static bool INumberBase<uint>.IsComplexNumber(uint value);
++        static bool INumberBase<uint>.IsFinite(uint value);
++        static bool INumberBase<uint>.IsImaginaryNumber(uint value);
++        static bool INumberBase<uint>.IsInfinity(uint value);
++        static bool INumberBase<uint>.IsInteger(uint value);
++        static bool INumberBase<uint>.IsNaN(uint value);
++        static bool INumberBase<uint>.IsNegative(uint value);
++        static bool INumberBase<uint>.IsNegativeInfinity(uint value);
++        static bool INumberBase<uint>.IsNormal(uint value);
++        static bool INumberBase<uint>.IsPositive(uint value);
++        static bool INumberBase<uint>.IsPositiveInfinity(uint value);
++        static bool INumberBase<uint>.IsRealNumber(uint value);
++        static bool INumberBase<uint>.IsSubnormal(uint value);
++        static bool INumberBase<uint>.IsZero(uint value);
++        static uint INumberBase<uint>.MaxMagnitude(uint x, uint y);
++        static uint INumberBase<uint>.MaxMagnitudeNumber(uint x, uint y);
++        static uint INumberBase<uint>.MinMagnitude(uint x, uint y);
++        static uint INumberBase<uint>.MinMagnitudeNumber(uint x, uint y);
++        static bool INumberBase<uint>.TryConvertFromChecked<TOther>(TOther value, out uint result);
++        static bool INumberBase<uint>.TryConvertFromSaturating<TOther>(TOther value, out uint result);
++        static bool INumberBase<uint>.TryConvertFromTruncating<TOther>(TOther value, out uint result);
++        static bool INumberBase<uint>.TryConvertToChecked<TOther>(uint value, out TOther result);
++        static bool INumberBase<uint>.TryConvertToSaturating<TOther>(uint value, out TOther result);
++        static bool INumberBase<uint>.TryConvertToTruncating<TOther>(uint value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out uint result) where TOther : INumber<TOther>;
+     }
+     public readonly struct UInt64 : IAdditionOperators<ulong, ulong, ulong>, IAdditiveIdentity<ulong, ulong>, IBinaryInteger<ulong>, IBinaryNumber<ulong>, IBitwiseOperators<ulong, ulong, ulong>, IComparable, IComparable<ulong>, IComparisonOperators<ulong, ulong>, IConvertible, IDecrementOperators<ulong>, IDivisionOperators<ulong, ulong, ulong>, IEqualityOperators<ulong, ulong>, IEquatable<ulong>, IFormattable, IIncrementOperators<ulong>, IMinMaxValue<ulong>, IModulusOperators<ulong, ulong, ulong>, IMultiplicativeIdentity<ulong, ulong>, IMultiplyOperators<ulong, ulong, ulong>, INumber<ulong>, INumberBase<ulong>, IParsable<ulong>, IShiftOperators<ulong, ulong>, ISpanFormattable, ISpanParsable<ulong>, ISubtractionOperators<ulong, ulong, ulong>, IUnaryNegationOperators<ulong, ulong>, IUnaryPlusOperators<ulong, ulong>, IUnsignedNumber<ulong> {
++        static int System.Numerics.INumberBase<System.UInt64>.Radix { get; }
+-        public static ulong CreateChecked<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static ulong CreateSaturating<TOther>(TOther value) where TOther : INumber<TOther>;
+-        public static ulong CreateTruncating<TOther>(TOther value) where TOther : INumber<TOther>;
++        public static bool IsEvenInteger(ulong value);
++        public static bool IsOddInteger(ulong value);
+-        long IBinaryInteger<ulong>.GetShortestBitLength();
++        int IBinaryInteger<ulong>.GetShortestBitLength();
++        bool IBinaryInteger<ulong>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static ulong INumber<ulong>.Abs(ulong value);
+-        static bool INumber<ulong>.IsNegative(ulong value);
+-        static ulong INumber<ulong>.MaxMagnitude(ulong x, ulong y);
++        static ulong INumber<ulong>.MaxNumber(ulong x, ulong y);
+-        static ulong INumber<ulong>.MinMagnitude(ulong x, ulong y);
++        static ulong INumber<ulong>.MinNumber(ulong x, ulong y);
++        static ulong INumberBase<ulong>.Abs(ulong value);
++        static bool INumberBase<ulong>.IsCanonical(ulong value);
++        static bool INumberBase<ulong>.IsComplexNumber(ulong value);
++        static bool INumberBase<ulong>.IsFinite(ulong value);
++        static bool INumberBase<ulong>.IsImaginaryNumber(ulong value);
++        static bool INumberBase<ulong>.IsInfinity(ulong value);
++        static bool INumberBase<ulong>.IsInteger(ulong value);
++        static bool INumberBase<ulong>.IsNaN(ulong value);
++        static bool INumberBase<ulong>.IsNegative(ulong value);
++        static bool INumberBase<ulong>.IsNegativeInfinity(ulong value);
++        static bool INumberBase<ulong>.IsNormal(ulong value);
++        static bool INumberBase<ulong>.IsPositive(ulong value);
++        static bool INumberBase<ulong>.IsPositiveInfinity(ulong value);
++        static bool INumberBase<ulong>.IsRealNumber(ulong value);
++        static bool INumberBase<ulong>.IsSubnormal(ulong value);
++        static bool INumberBase<ulong>.IsZero(ulong value);
++        static ulong INumberBase<ulong>.MaxMagnitude(ulong x, ulong y);
++        static ulong INumberBase<ulong>.MaxMagnitudeNumber(ulong x, ulong y);
++        static ulong INumberBase<ulong>.MinMagnitude(ulong x, ulong y);
++        static ulong INumberBase<ulong>.MinMagnitudeNumber(ulong x, ulong y);
++        static bool INumberBase<ulong>.TryConvertFromChecked<TOther>(TOther value, out ulong result);
++        static bool INumberBase<ulong>.TryConvertFromSaturating<TOther>(TOther value, out ulong result);
++        static bool INumberBase<ulong>.TryConvertFromTruncating<TOther>(TOther value, out ulong result);
++        static bool INumberBase<ulong>.TryConvertToChecked<TOther>(ulong value, out TOther result);
++        static bool INumberBase<ulong>.TryConvertToSaturating<TOther>(ulong value, out TOther result);
++        static bool INumberBase<ulong>.TryConvertToTruncating<TOther>(ulong value, out TOther result);
+-        public static bool TryCreate<TOther>(TOther value, out ulong result) where TOther : INumber<TOther>;
+     }
+     public readonly struct UIntPtr : IAdditionOperators<UIntPtr, UIntPtr, UIntPtr>, IAdditiveIdentity<UIntPtr, UIntPtr>, IBinaryInteger<UIntPtr>, IBinaryNumber<UIntPtr>, IBitwiseOperators<UIntPtr, UIntPtr, UIntPtr>, IComparable, IComparable<UIntPtr>, IComparisonOperators<UIntPtr, UIntPtr>, IDecrementOperators<UIntPtr>, IDivisionOperators<UIntPtr, UIntPtr, UIntPtr>, IEqualityOperators<UIntPtr, UIntPtr>, IEquatable<UIntPtr>, IFormattable, IIncrementOperators<UIntPtr>, IMinMaxValue<UIntPtr>, IModulusOperators<UIntPtr, UIntPtr, UIntPtr>, IMultiplicativeIdentity<UIntPtr, UIntPtr>, IMultiplyOperators<UIntPtr, UIntPtr, UIntPtr>, INumber<UIntPtr>, INumberBase<UIntPtr>, IParsable<UIntPtr>, ISerializable, IShiftOperators<UIntPtr, UIntPtr>, ISpanFormattable, ISpanParsable<UIntPtr>, ISubtractionOperators<UIntPtr, UIntPtr, UIntPtr>, IUnaryNegationOperators<UIntPtr, UIntPtr>, IUnaryPlusOperators<UIntPtr, UIntPtr>, IUnsignedNumber<UIntPtr> {
++        static int System.Numerics.INumberBase<nuint>.Radix { get; }
++        public static UIntPtr Clamp(UIntPtr value, UIntPtr min, UIntPtr max);
++        public static (UIntPtr Quotient, UIntPtr Remainder) DivRem(UIntPtr left, UIntPtr right);
++        public static bool IsEvenInteger(UIntPtr value);
++        public static bool IsOddInteger(UIntPtr value);
++        public static bool IsPow2(UIntPtr value);
++        public static UIntPtr LeadingZeroCount(UIntPtr value);
++        public static UIntPtr Log2(UIntPtr value);
++        public static UIntPtr Max(UIntPtr x, UIntPtr y);
++        public static UIntPtr Min(UIntPtr x, UIntPtr y);
++        public static UIntPtr PopCount(UIntPtr value);
++        public static UIntPtr RotateLeft(UIntPtr value, int rotateAmount);
++        public static UIntPtr RotateRight(UIntPtr value, int rotateAmount);
++        public static int Sign(UIntPtr value);
+-        static (UIntPtr Quotient, UIntPtr Remainder) IBinaryInteger<UIntPtr>.DivRem(UIntPtr left, UIntPtr right);
+-        long IBinaryInteger<UIntPtr>.GetShortestBitLength();
++        int IBinaryInteger<UIntPtr>.GetShortestBitLength();
+-        static UIntPtr IBinaryInteger<UIntPtr>.LeadingZeroCount(UIntPtr value);
+-        static UIntPtr IBinaryInteger<UIntPtr>.PopCount(UIntPtr value);
+-        static UIntPtr IBinaryInteger<UIntPtr>.RotateLeft(UIntPtr value, int rotateAmount);
+-        static UIntPtr IBinaryInteger<UIntPtr>.RotateRight(UIntPtr value, int rotateAmount);
+-        static UIntPtr IBinaryInteger<UIntPtr>.TrailingZeroCount(UIntPtr value);
++        bool IBinaryInteger<UIntPtr>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten);
+-        static bool IBinaryNumber<UIntPtr>.IsPow2(UIntPtr value);
+-        static UIntPtr IBinaryNumber<UIntPtr>.Log2(UIntPtr value);
+-        static UIntPtr INumber<UIntPtr>.Abs(UIntPtr value);
+-        static UIntPtr INumber<UIntPtr>.Clamp(UIntPtr value, UIntPtr min, UIntPtr max);
+-        static UIntPtr INumber<UIntPtr>.CreateChecked<TOther>(TOther value);
+-        static UIntPtr INumber<UIntPtr>.CreateSaturating<TOther>(TOther value);
+-        static UIntPtr INumber<UIntPtr>.CreateTruncating<TOther>(TOther value);
+-        static bool INumber<UIntPtr>.IsNegative(UIntPtr value);
+-        static UIntPtr INumber<UIntPtr>.Max(UIntPtr x, UIntPtr y);
+-        static UIntPtr INumber<UIntPtr>.MaxMagnitude(UIntPtr x, UIntPtr y);
++        static UIntPtr INumber<UIntPtr>.MaxNumber(UIntPtr x, UIntPtr y);
+-        static UIntPtr INumber<UIntPtr>.Min(UIntPtr x, UIntPtr y);
+-        static UIntPtr INumber<UIntPtr>.MinMagnitude(UIntPtr x, UIntPtr y);
++        static UIntPtr INumber<UIntPtr>.MinNumber(UIntPtr x, UIntPtr y);
+-        static int INumber<UIntPtr>.Sign(UIntPtr value);
+-        static bool INumber<UIntPtr>.TryCreate<TOther>(TOther value, out UIntPtr result);
++        static UIntPtr INumberBase<UIntPtr>.Abs(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsCanonical(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsComplexNumber(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsFinite(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsImaginaryNumber(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsInfinity(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsInteger(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsNaN(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsNegative(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsNegativeInfinity(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsNormal(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsPositive(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsPositiveInfinity(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsRealNumber(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsSubnormal(UIntPtr value);
++        static bool INumberBase<UIntPtr>.IsZero(UIntPtr value);
++        static UIntPtr INumberBase<UIntPtr>.MaxMagnitude(UIntPtr x, UIntPtr y);
++        static UIntPtr INumberBase<UIntPtr>.MaxMagnitudeNumber(UIntPtr x, UIntPtr y);
++        static UIntPtr INumberBase<UIntPtr>.MinMagnitude(UIntPtr x, UIntPtr y);
++        static UIntPtr INumberBase<UIntPtr>.MinMagnitudeNumber(UIntPtr x, UIntPtr y);
++        static bool INumberBase<UIntPtr>.TryConvertFromChecked<TOther>(TOther value, out UIntPtr result);
++        static bool INumberBase<UIntPtr>.TryConvertFromSaturating<TOther>(TOther value, out UIntPtr result);
++        static bool INumberBase<UIntPtr>.TryConvertFromTruncating<TOther>(TOther value, out UIntPtr result);
++        static bool INumberBase<UIntPtr>.TryConvertToChecked<TOther>(UIntPtr value, out TOther result);
++        static bool INumberBase<UIntPtr>.TryConvertToSaturating<TOther>(UIntPtr value, out TOther result);
++        static bool INumberBase<UIntPtr>.TryConvertToTruncating<TOther>(UIntPtr value, out TOther result);
++        public static UIntPtr TrailingZeroCount(UIntPtr value);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md
new file mode 100644
index 00000000..bc1b4c61
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5.md
@@ -0,0 +1,11 @@
+# API Difference 7.0-preview4 vs 7.0-preview5
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [System.Diagnostics](7.0-preview5_System.Diagnostics.md)
+* [System.Security.Permissions](7.0-preview5_System.Security.Permissions.md)
+* [System.Windows.Forms](7.0-preview5_System.Windows.Forms.md)
+* [System.Windows.Forms.Design](7.0-preview5_System.Windows.Forms.Design.md)
+* [System.Windows.Forms.Layout](7.0-preview5_System.Windows.Forms.Layout.md)
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md
new file mode 100644
index 00000000..68f7bc77
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Diagnostics.md
@@ -0,0 +1,10 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public sealed class PerformanceCounter : Component, ISupportInitialize {
+         public static int DefaultFileMappingSize;
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md
new file mode 100644
index 00000000..d2590ff5
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Security.Permissions.md
@@ -0,0 +1,19 @@
+# System.Security.Permissions
+
+``` diff
+ namespace System.Security.Permissions {
+     public sealed class ReflectionPermissionAttribute : CodeAccessSecurityAttribute {
+         public bool ReflectionEmit { get; set; }
+         public bool TypeInformation { get; set; }
+     }
+     public enum ReflectionPermissionFlag {
+         AllFlags = 7,
+         ReflectionEmit = 4,
+         TypeInformation = 1,
+     }
+     public sealed class RegistryPermissionAttribute : CodeAccessSecurityAttribute {
+         public string All { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md
new file mode 100644
index 00000000..23bf2411
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Design.md
@@ -0,0 +1,11 @@
+# System.Windows.Forms.Design
+
+``` diff
+ namespace System.Windows.Forms.Design {
+     public sealed class ToolStripItemDesignerAvailabilityAttribute : Attribute {
+-        public override bool Equals(object obj);
++        public override bool Equals(object? obj);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md
new file mode 100644
index 00000000..ac317ca9
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.Layout.md
@@ -0,0 +1,17 @@
+# System.Windows.Forms.Layout
+
+``` diff
+ namespace System.Windows.Forms.Layout {
+     public class TableLayoutSettingsTypeConverter : TypeConverter {
+-        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++        public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType);
+-        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
++        public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType);
+-        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
++        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? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType);
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md
new file mode 100644
index 00000000..79757bdf
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/Microsoft.WindowsDesktop.App/7.0-preview5_System.Windows.Forms.md
@@ -0,0 +1,227 @@
+# System.Windows.Forms
+
+``` diff
+ namespace System.Windows.Forms {
+     public abstract class AxHost : Control, ICustomTypeDescriptor, ISupportInitialize {
+         public class State : ISerializable {
+-            public State(Stream ms, int storageType, bool manualUpdate, string licKey);
++            public State(Stream ms, int storageType, bool manualUpdate, string? licKey);
+         }
+     }
+-    public struct BindingMemberInfo {
++    public struct BindingMemberInfo : IEquatable<BindingMemberInfo> {
++        public bool Equals(BindingMemberInfo other);
+     }
+     public class ContextMenuStrip : ToolStripDropDownMenu {
+-        public Control SourceControl { get; }
++        public Control? SourceControl { get; }
+     }
+     public class Control : Component, IArrangedElement, IBindableComponent, IComponent, IDisposable, IDropTarget, IHandle, IKeyboardToolTip, Interop.Ole32.IOleControl, Interop.Ole32.IOleInPlaceActiveObject, Interop.Ole32.IOleInPlaceObject, Interop.Ole32.IOleObject, Interop.Ole32.IOleWindow, Interop.Ole32.IPersist, Interop.Ole32.IPersistStorage, Interop.Ole32.IPersistStreamInit, Interop.Ole32.IQuickActivate, Interop.Ole32.IViewObject, Interop.Ole32.IViewObject2, Interop.Oleaut32.IPersistPropertyBag, ISupportOleDropSource, ISynchronizeInvoke, IWin32Window {
+-        public Control(string text);
++        public Control(string? text);
+-        public Control(string text, int left, int top, int width, int height);
++        public Control(string? text, int left, int top, int width, int height);
+-        public Control(Control parent, string text);
++        public Control(Control? parent, string? text);
+-        public Control(Control parent, string text, int left, int top, int width, int height);
++        public Control(Control? parent, string? text, int left, int top, int width, int height);
+-        public string AccessibleDefaultActionDescription { get; set; }
++        public string? AccessibleDefaultActionDescription { get; set; }
+-        public string AccessibleDescription { get; set; }
++        public string? AccessibleDescription { get; set; }
+-        public string AccessibleName { get; set; }
++        public string? AccessibleName { get; set; }
+-        public virtual Image BackgroundImage { get; set; }
++        public virtual Image? BackgroundImage { get; set; }
+-        public virtual BindingContext BindingContext { get; set; }
++        public virtual BindingContext? BindingContext { get; set; }
+-        public virtual ContextMenuStrip ContextMenuStrip { get; set; }
++        public virtual ContextMenuStrip? ContextMenuStrip { get; set; }
+         public virtual Cursor Cursor { get; set; }
+         public virtual Font Font { get; set; }
+-        public event EventHandler AutoSizeChanged;
++        public event EventHandler? AutoSizeChanged;
+-        public event EventHandler BackColorChanged;
++        public event EventHandler? BackColorChanged;
+-        public event EventHandler BackgroundImageChanged;
++        public event EventHandler? BackgroundImageChanged;
+-        public event EventHandler BackgroundImageLayoutChanged;
++        public event EventHandler? BackgroundImageLayoutChanged;
+-        public event EventHandler BindingContextChanged;
++        public event EventHandler? BindingContextChanged;
+-        public event EventHandler CausesValidationChanged;
++        public event EventHandler? CausesValidationChanged;
+-        public event EventHandler ClientSizeChanged;
++        public event EventHandler? ClientSizeChanged;
+-        public event EventHandler ContextMenuStripChanged;
++        public event EventHandler? ContextMenuStripChanged;
+-        public event EventHandler CursorChanged;
++        public event EventHandler? CursorChanged;
+-        public event EventHandler DockChanged;
++        public event EventHandler? DockChanged;
+-        public event EventHandler EnabledChanged;
++        public event EventHandler? EnabledChanged;
+-        public event EventHandler FontChanged;
++        public event EventHandler? FontChanged;
+-        public event EventHandler ForeColorChanged;
++        public event EventHandler? ForeColorChanged;
+-        protected virtual AccessibleObject GetAccessibilityObjectById(int objectId);
++        protected virtual AccessibleObject? GetAccessibilityObjectById(int objectId);
+-        public bool SelectNextControl(Control ctl, bool forward, bool tabStopOnly, bool nested, bool wrap);
++        public bool SelectNextControl(Control? ctl, bool forward, bool tabStopOnly, bool nested, bool wrap);
+     }
+     public sealed class DataGridViewAdvancedBorderStyle : ICloneable {
+-        public override bool Equals(object other);
++        public override bool Equals(object? other);
+     }
+     public class Form : ContainerControl {
++        protected override void OnGotFocus(EventArgs e);
+     }
+     public class Label : Control, IAutomationLiveRegion {
+         public override string Text { get; set; }
+     }
+-    public struct LinkArea {
++    public struct LinkArea : IEquatable<LinkArea> {
+-        public override bool Equals(object o);
++        public override bool Equals(object? o);
++        public bool Equals(LinkArea other);
+         public class LinkAreaConverter : TypeConverter {
+-            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
++            public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType);
+-            public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues);
++            public override object CreateInstance(ITypeDescriptorContext? context, IDictionary propertyValues);
+-            public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes);
++            public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext? context, object value, Attribute[]? attributes);
+         }
+     }
+     public class ListBox : ListControl {
+         public override Font Font { get; set; }
+     }
+     public class ListView : Control {
+         public class CheckedListViewItemCollection : ICollection, IEnumerable, IList {
+-            bool System.Collections.ICollection.IsSynchronized { get; }
++            bool ICollection.IsSynchronized { get; }
+-            object System.Collections.ICollection.SyncRoot { get; }
++            object ICollection.SyncRoot { get; }
+-            bool System.Collections.IList.IsFixedSize { get; }
++            bool IList.IsFixedSize { get; }
+-            object System.Collections.IList.this[int index] { get; set; }
++            object IList.this[int index] { get; set; }
+         }
+         public class SelectedListViewItemCollection : ICollection, IEnumerable, IList {
+-            bool System.Collections.ICollection.IsSynchronized { get; }
++            bool ICollection.IsSynchronized { get; }
+-            object System.Collections.ICollection.SyncRoot { get; }
++            object ICollection.SyncRoot { get; }
+-            bool System.Collections.IList.IsFixedSize { get; }
++            bool IList.IsFixedSize { get; }
+-            object System.Collections.IList.this[int index] { get; set; }
++            object IList.this[int index] { get; set; }
+         }
+     }
+     public class ListViewHitTestInfo {
+         public ListViewItem Item { get; }
+         public ListViewHitTestLocations Location { get; }
+         public ListViewItem.ListViewSubItem SubItem { get; }
+     }
+-    public struct Message {
++    public struct Message : IEquatable<Message> {
++        public bool Equals(Message other);
+     }
+     public sealed class NotifyIcon : Component {
+         public string Text { get; set; }
+     }
+-    public struct Padding {
++    public struct Padding : IEquatable<Padding> {
++        public bool Equals(Padding other);
+     }
+     public class PrintPreviewDialog : Form {
+         public override Cursor Cursor { get; set; }
+         public override Font Font { get; set; }
+     }
+     public class ProgressBar : Control {
+         public override Font Font { get; set; }
+     }
+     public abstract class ScrollBar : Control {
+         public override Font Font { get; set; }
+     }
+     public class Splitter : Control {
+         public override Font Font { get; set; }
+     }
+     public class TabControl : Control {
+         public class TabPageCollection : ICollection, IEnumerable, IList {
+-            bool System.Collections.ICollection.IsSynchronized { get; }
++            bool ICollection.IsSynchronized { get; }
+-            object System.Collections.ICollection.SyncRoot { get; }
++            object ICollection.SyncRoot { get; }
+-            bool System.Collections.IList.IsFixedSize { get; }
++            bool IList.IsFixedSize { get; }
+-            object System.Collections.IList.this[int index] { get; set; }
++            object IList.this[int index] { get; set; }
+         }
+     }
+-    public struct TableLayoutPanelCellPosition {
++    public struct TableLayoutPanelCellPosition : IEquatable<TableLayoutPanelCellPosition> {
++        public bool Equals(TableLayoutPanelCellPosition other);
+     }
+     public class TabPage : Panel {
+         public string ImageKey { get; set; }
+         public override string Text { get; set; }
+         public string ToolTipText { get; set; }
+     }
+     public class ToolStripContentPanel : Panel {
+         public new string Name { get; set; }
+     }
+     public class ToolStripDropDownMenu : ToolStripDropDown {
++        protected override AccessibleObject CreateAccessibilityInstance();
+     }
+     public class TrackBar : Control, ISupportInitialize {
+         public override Font Font { get; set; }
+     }
+     public class TreeViewImageIndexConverter : ImageIndexConverter {
+-        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
++        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext? context);
+     }
+     public class TreeViewImageKeyConverter : ImageKeyConverter {
+-        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
++        public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType);
+     }
+     public abstract class UpDownBase : ContainerControl {
+-        public override Image BackgroundImage { get; set; }
++        public override Image? BackgroundImage { get; set; }
+-        public override ContextMenuStrip ContextMenuStrip { get; set; }
++        public override ContextMenuStrip? ContextMenuStrip { get; set; }
+         public override string Text { get; set; }
+-        public new event EventHandler AutoSizeChanged;
++        public new event EventHandler? AutoSizeChanged;
+-        public new event EventHandler BackgroundImageChanged;
++        public new event EventHandler? BackgroundImageChanged;
+-        public new event EventHandler BackgroundImageLayoutChanged;
++        public new event EventHandler? BackgroundImageLayoutChanged;
+-        public new event EventHandler MouseEnter;
++        public new event EventHandler? MouseEnter;
+-        public new event EventHandler MouseHover;
++        public new event EventHandler? MouseHover;
+-        public new event EventHandler MouseLeave;
++        public new event EventHandler? MouseLeave;
+-        public new event MouseEventHandler MouseMove;
++        public new event MouseEventHandler? MouseMove;
+-        protected virtual void OnChanged(object source, EventArgs e);
++        protected virtual void OnChanged(object? source, EventArgs e);
+-        protected virtual void OnTextBoxKeyDown(object source, KeyEventArgs e);
++        protected virtual void OnTextBoxKeyDown(object? source, KeyEventArgs e);
+-        protected virtual void OnTextBoxKeyPress(object source, KeyPressEventArgs e);
++        protected virtual void OnTextBoxKeyPress(object? source, KeyPressEventArgs e);
+-        protected virtual void OnTextBoxLostFocus(object source, EventArgs e);
++        protected virtual void OnTextBoxLostFocus(object? source, EventArgs e);
+-        protected virtual void OnTextBoxResize(object source, EventArgs e);
++        protected virtual void OnTextBoxResize(object? source, EventArgs e);
+-        protected virtual void OnTextBoxTextChanged(object source, EventArgs e);
++        protected virtual void OnTextBoxTextChanged(object? source, EventArgs e);
+     }
+     public class UserControl : ContainerControl {
+         public override string Text { get; set; }
+     }
+ }
+```
+
diff --git a/release-notes/7.0/preview/api-diff/preview5/README.md b/release-notes/7.0/preview/api-diff/preview5/README.md
new file mode 100644
index 00000000..e2087f33
--- /dev/null
+++ b/release-notes/7.0/preview/api-diff/preview5/README.md
@@ -0,0 +1,7 @@
+# .NET 7.0 Preview 5 API Changes
+
+The following API changes were made in .NET 7.0 Preview 5:
+
+- [Microsoft.NETCore.App](./Microsoft.NETCore.App/7.0-preview5.md)
+- [Microsoft.AspNetCore.App](./Microsoft.AspNetCore.App/7.0-preview5.md)
+- [Microsoft.WindowsDesktop.App](./Microsoft.WindowsDesktop.App/7.0-preview5.md)