API diff between .NET 9 Preview 6 and .NET 9 Preview 7 (#9450)

* Microsoft.AspNetCore.App

* Microsoft.NETCore.App

* Microsoft.WindowsDesktop.App

* README.md

* Apply suggestions from code review

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7.md

@@ -0,0 +1,22 @@
+# API Difference 9.0-preview6 vs 9.0-preview7
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [Microsoft.AspNetCore.Builder](9.0-preview7_Microsoft.AspNetCore.Builder.md)
+* [Microsoft.AspNetCore.Components.Authorization](9.0-preview7_Microsoft.AspNetCore.Components.Authorization.md)
+* [Microsoft.AspNetCore.DataProtection.KeyManagement](9.0-preview7_Microsoft.AspNetCore.DataProtection.KeyManagement.md)
+* [Microsoft.AspNetCore.DataProtection.Repositories](9.0-preview7_Microsoft.AspNetCore.DataProtection.Repositories.md)
+* [Microsoft.AspNetCore.Http](9.0-preview7_Microsoft.AspNetCore.Http.md)
+* [Microsoft.AspNetCore.Http.Features](9.0-preview7_Microsoft.AspNetCore.Http.Features.md)
+* [Microsoft.AspNetCore.Http.Metadata](9.0-preview7_Microsoft.AspNetCore.Http.Metadata.md)
+* [Microsoft.AspNetCore.Http.Timeouts](9.0-preview7_Microsoft.AspNetCore.Http.Timeouts.md)
+* [Microsoft.AspNetCore.Mvc.ApiExplorer](9.0-preview7_Microsoft.AspNetCore.Mvc.ApiExplorer.md)
+* [Microsoft.AspNetCore.Mvc.ModelBinding](9.0-preview7_Microsoft.AspNetCore.Mvc.ModelBinding.md)
+* [Microsoft.AspNetCore.Server.Kestrel](9.0-preview7_Microsoft.AspNetCore.Server.Kestrel.md)
+* [Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes](9.0-preview7_Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes.md)
+* [Microsoft.Extensions.Caching.Distributed](9.0-preview7_Microsoft.Extensions.Caching.Distributed.md)
+* [Microsoft.Extensions.Caching.Hybrid](9.0-preview7_Microsoft.Extensions.Caching.Hybrid.md)
+* [Microsoft.Extensions.DependencyInjection](9.0-preview7_Microsoft.Extensions.DependencyInjection.md)
+* [Microsoft.Extensions.Logging.Abstractions](9.0-preview7_Microsoft.Extensions.Logging.Abstractions.md)
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Builder.md

@@ -0,0 +1,13 @@
+# Microsoft.AspNetCore.Builder
+
+``` diff
+ namespace Microsoft.AspNetCore.Builder {
+     public class ExceptionHandlerOptions {
++        public Func<Exception, int>? StatusCodeSelector { get; set; }
+     }
++    public static class HttpMetricsEndpointConventionBuilderExtensions {
++        public static TBuilder DisableHttpMetrics<TBuilder>(this TBuilder builder) where TBuilder : IEndpointConventionBuilder;
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Components.Authorization.md

@@ -0,0 +1,18 @@
+# Microsoft.AspNetCore.Components.Authorization
+
+``` diff
+ namespace Microsoft.AspNetCore.Components.Authorization {
+     public class AuthenticationStateData {
+-        public IList<KeyValuePair<string, string>> Claims { get; set; }
++        public IList<ClaimData> Claims { get; set; }
+     }
++    public readonly struct ClaimData {
++        public ClaimData(Claim claim);
++        [JsonConstructorAttribute]
++        public ClaimData(string type, string value);
++        public string Type { get; }
++        public string Value { get; }
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.DataProtection.KeyManagement.md

@@ -0,0 +1,15 @@
+# Microsoft.AspNetCore.DataProtection.KeyManagement
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.KeyManagement {
++    public interface IDeletableKeyManager : IKeyManager {
++        bool CanDeleteKeys { get; }
++        bool DeleteKeys(Func<IKey, bool> shouldDelete);
++    }
+     public sealed class XmlKeyManager : IInternalXmlKeyManager, IKeyManager {
++        public bool CanDeleteKeys { get; }
++        public bool DeleteKeys(Func<IKey, bool> shouldDelete);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.DataProtection.Repositories.md

@@ -0,0 +1,24 @@
+# Microsoft.AspNetCore.DataProtection.Repositories
+
+``` diff
+ namespace Microsoft.AspNetCore.DataProtection.Repositories {
+-    public class FileSystemXmlRepository : IXmlRepository {
++    public class FileSystemXmlRepository : IDeletableXmlRepository, IXmlRepository {
++        public virtual bool DeleteElements(Action<IReadOnlyCollection<IDeletableElement>> chooseElements);
+     }
++    public interface IDeletableElement {
++        int? DeletionOrder { get; set; }
++        XElement Element { get; }
++    }
++    public interface IDeletableXmlRepository : IXmlRepository {
++        bool DeleteElements(Action<IReadOnlyCollection<IDeletableElement>> chooseElements);
++    }
+-    [SupportedOSPlatformAttribute("windows")]
+-    public class RegistryXmlRepository : IXmlRepository {
++    [SupportedOSPlatformAttribute("windows")]
++    public class RegistryXmlRepository : IDeletableXmlRepository, IXmlRepository {
++        public virtual bool DeleteElements(Action<IReadOnlyCollection<IDeletableElement>> chooseElements);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Http.Features.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Http.Features
+
+``` diff
+ namespace Microsoft.AspNetCore.Http.Features {
+     public interface IHttpMetricsTagsFeature {
++        bool MetricsDisabled { get; set; }
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Http.Metadata.md

@@ -0,0 +1,15 @@
+# Microsoft.AspNetCore.Http.Metadata
+
+``` diff
+ namespace Microsoft.AspNetCore.Http.Metadata {
++    public interface IDisableHttpMetricsMetadata
++    public interface IParameterBindingMetadata {
++        bool HasBindAsync { get; }
++        bool HasTryParse { get; }
++        bool IsOptional { get; }
++        string Name { get; }
++        ParameterInfo ParameterInfo { get; }
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Http.Timeouts.md

@@ -0,0 +1,14 @@
+# Microsoft.AspNetCore.Http.Timeouts
+
+``` diff
+ namespace Microsoft.AspNetCore.Http.Timeouts {
+-    [AttributeUsageAttribute(68)]
+-    public sealed class DisableRequestTimeoutAttribute : Attribute {
++    [AttributeUsageAttribute(68)]
++    [DebuggerDisplayAttribute("{ToString(),nq}")]
++    public sealed class DisableRequestTimeoutAttribute : Attribute {
++        public override string ToString();
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Http.md

@@ -0,0 +1,36 @@
+# Microsoft.AspNetCore.Http
+
+``` diff
+ namespace Microsoft.AspNetCore.Http {
++    [AttributeUsageAttribute(68)]
++    [DebuggerDisplayAttribute("{ToString(),nq}")]
++    public sealed class DisableHttpMetricsAttribute : Attribute, IDisableHttpMetricsMetadata {
++        public DisableHttpMetricsAttribute();
++        public override string ToString();
++    }
+     public class HttpValidationProblemDetails : ProblemDetails {
++        public HttpValidationProblemDetails(IEnumerable<KeyValuePair<string, string[]>> errors);
+     }
+     public static class OpenApiRouteHandlerBuilderExtensions {
++        public static TBuilder ProducesProblem<TBuilder>(this TBuilder builder, int statusCode, string? contentType = null) where TBuilder : IEndpointConventionBuilder;
++        public static TBuilder ProducesValidationProblem<TBuilder>(this TBuilder builder, int statusCode = 400, string? contentType = null) where TBuilder : IEndpointConventionBuilder;
+     }
+     public static class Results {
+-        public static IResult Problem(string detail = null, string instance = null, int? statusCode = default(int?), string title = null, string type = null, IDictionary<string, object?>? extensions = null);
++        public static IResult Problem(string detail, string instance, int? statusCode, string title, string type, IDictionary<string, object?>? extensions);
++        public static IResult Problem(string detail = null, string instance = null, int? statusCode = default(int?), string title = null, string type = null, IEnumerable<KeyValuePair<string, object?>>? extensions = null);
+-        public static IResult ValidationProblem(IDictionary<string, string[]> errors, string detail = null, string instance = null, int? statusCode = default(int?), string title = null, string type = null, IDictionary<string, object?>? extensions = null);
++        public static IResult ValidationProblem(IDictionary<string, string[]> errors, string detail, string instance, int? statusCode, string title, string type, IDictionary<string, object?>? extensions);
++        public static IResult ValidationProblem(IEnumerable<KeyValuePair<string, string[]>> errors, string detail = null, string instance = null, int? statusCode = default(int?), string title = null, string type = null, IEnumerable<KeyValuePair<string, object?>>? extensions = null);
+     }
+     public static class TypedResults {
+-        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, string instance, int? statusCode, string title, string type, IDictionary<string, object?>? extensions);
++        public static ProblemHttpResult Problem(string detail = null, string instance = null, int? statusCode = default(int?), string title = null, string type = null, IEnumerable<KeyValuePair<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 ValidationProblem ValidationProblem(IDictionary<string, string[]> errors, string detail, string instance, string title, string type, IDictionary<string, object?>? extensions);
++        public static ValidationProblem ValidationProblem(IEnumerable<KeyValuePair<string, string[]>> errors, string detail = null, string instance = null, string title = null, string type = null, IEnumerable<KeyValuePair<string, object?>>? extensions = null);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Mvc.ApiExplorer.md

@@ -0,0 +1,10 @@
+# Microsoft.AspNetCore.Mvc.ApiExplorer
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.ApiExplorer {
+-    public class DefaultApiDescriptionProvider : IApiDescriptionProvider
++    [RequiresUnreferencedCodeAttribute("DefaultApiDescriptionProvider is used by MVC which does not currently support trimming or native AOT.", Url="https://aka.ms/aspnet/trimming")]
++    public class DefaultApiDescriptionProvider : IApiDescriptionProvider
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Mvc.ModelBinding.md

@@ -0,0 +1,16 @@
+# Microsoft.AspNetCore.Mvc.ModelBinding
+
+``` diff
+ namespace Microsoft.AspNetCore.Mvc.ModelBinding {
+     [DebuggerDisplayAttribute("{DebuggerToString(),nq}")]
+     public abstract class ModelMetadata : IEquatable<ModelMetadata?>, IModelMetadataProvider {
+-        public Type ElementType { get; }
++        public Type ElementType { [RequiresUnreferencedCodeAttribute("Resolving this property is not compatible with trimming, as it requires dynamic access to code that is not referenced statically.")] get; }
+-        public bool IsCollectionType { get; }
++        public bool IsCollectionType { [RequiresUnreferencedCodeAttribute("Resolving this property is not compatible with trimming, as it requires dynamic access to code that is not referenced statically.")] get; }
+-        public bool IsComplexType { get; }
++        public bool IsComplexType { [RequiresUnreferencedCodeAttribute("Resolving this property is not compatible with trimming, as it requires dynamic access to code that is not referenced statically.")] get; }
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes.md

@@ -0,0 +1,17 @@
+# Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes
+
+``` diff
+ namespace Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes {
++    public sealed class CreateNamedPipeServerStreamContext {
++        public CreateNamedPipeServerStreamContext();
++        public required NamedPipeEndPoint NamedPipeEndPoint { get; set; }
++        public required PipeOptions PipeOptions { get; set; }
++        public PipeSecurity? PipeSecurity { get; set; }
++    }
+     public sealed class NamedPipeTransportOptions {
++        public Func<CreateNamedPipeServerStreamContext, NamedPipeServerStream> CreateNamedPipeServerStream { get; set; }
++        public static NamedPipeServerStream CreateDefaultNamedPipeServerStream(CreateNamedPipeServerStreamContext context);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.AspNetCore.Server.Kestrel.md

@@ -0,0 +1,11 @@
+# Microsoft.AspNetCore.Server.Kestrel
+
+``` diff
+ namespace Microsoft.AspNetCore.Server.Kestrel {
+     public class KestrelConfigurationLoader {
++        public KestrelConfigurationLoader NamedPipeEndpoint(string pipeName);
++        public KestrelConfigurationLoader NamedPipeEndpoint(string pipeName, Action<ListenOptions> configure);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.Extensions.Caching.Distributed.md

@@ -0,0 +1,13 @@
+# Microsoft.Extensions.Caching.Distributed
+
+``` diff
+ namespace Microsoft.Extensions.Caching.Distributed {
++    public interface IBufferDistributedCache : IDistributedCache {
++        void Set(string key, ReadOnlySequence<byte> value, DistributedCacheEntryOptions options);
++        ValueTask SetAsync(string key, ReadOnlySequence<byte> value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken));
++        bool TryGet(string key, IBufferWriter<byte> destination);
++        ValueTask<bool> TryGetAsync(string key, IBufferWriter<byte> destination, CancellationToken token = default(CancellationToken));
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.Extensions.Caching.Hybrid.md

@@ -0,0 +1,42 @@
+# Microsoft.Extensions.Caching.Hybrid
+
+``` diff
++namespace Microsoft.Extensions.Caching.Hybrid {
++    public abstract class HybridCache {
++        protected HybridCache();
++        public ValueTask<T> GetOrCreateAsync<T>(string key, Func<CancellationToken, ValueTask<T>> factory, HybridCacheEntryOptions? options = null, IEnumerable<string>? tags = null, CancellationToken cancellationToken = default(CancellationToken));
++        public abstract ValueTask<T> GetOrCreateAsync<TState, T>(string key, TState state, Func<TState, CancellationToken, ValueTask<T>> factory, HybridCacheEntryOptions? options = null, IEnumerable<string>? tags = null, CancellationToken cancellationToken = default(CancellationToken));
++        public virtual ValueTask RemoveAsync(IEnumerable<string> keys, CancellationToken cancellationToken = default(CancellationToken));
++        public abstract ValueTask RemoveAsync(string key, CancellationToken cancellationToken = default(CancellationToken));
++        public virtual ValueTask RemoveByTagAsync(IEnumerable<string> tags, CancellationToken cancellationToken = default(CancellationToken));
++        public abstract ValueTask RemoveByTagAsync(string tag, CancellationToken cancellationToken = default(CancellationToken));
++        public abstract ValueTask SetAsync<T>(string key, T value, HybridCacheEntryOptions? options = null, IEnumerable<string>? tags = null, CancellationToken cancellationToken = default(CancellationToken));
++    }
++    [FlagsAttribute]
++    public enum HybridCacheEntryFlags {
++        DisableCompression = 32,
++        DisableDistributedCache = 12,
++        DisableDistributedCacheRead = 4,
++        DisableDistributedCacheWrite = 8,
++        DisableLocalCache = 3,
++        DisableLocalCacheRead = 1,
++        DisableLocalCacheWrite = 2,
++        DisableUnderlyingData = 16,
++        None = 0,
++    }
++    public sealed class HybridCacheEntryOptions {
++        public HybridCacheEntryOptions();
++        public TimeSpan? Expiration { get; set; }
++        public HybridCacheEntryFlags? Flags { get; set; }
++        public TimeSpan? LocalCacheExpiration { get; set; }
++    }
++    public interface IHybridCacheSerializer<T> {
++        T Deserialize(ReadOnlySequence<byte> source);
++        void Serialize(T value, IBufferWriter<byte> target);
++    }
++    public interface IHybridCacheSerializerFactory {
++        bool TryCreateSerializer<T>([NotNullWhenAttribute(true)] out IHybridCacheSerializer<T>? serializer);
++    }
++}
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.Extensions.DependencyInjection.md

@@ -0,0 +1,24 @@
+# Microsoft.Extensions.DependencyInjection
+
+``` diff
+ namespace Microsoft.Extensions.DependencyInjection {
+     public static class HttpClientBuilderExtensions {
++        public static IHttpClientBuilder AddAsKeyed(this IHttpClientBuilder builder, ServiceLifetime lifetime = ServiceLifetime.Scoped);
++        public static IHttpClientBuilder RemoveAsKeyed(this IHttpClientBuilder builder);
+     }
+     public static class MvcApiExplorerMvcCoreBuilderExtensions {
+-        public static IMvcCoreBuilder AddApiExplorer(this IMvcCoreBuilder builder);
++        [RequiresUnreferencedCodeAttribute("MVC does not currently support trimming or native AOT.", Url="https://aka.ms/aspnet/trimming")]
++        public static IMvcCoreBuilder AddApiExplorer(this IMvcCoreBuilder builder);
+     }
+     public static class SignalRDependencyInjectionExtensions {
+-        [RequiresUnreferencedCodeAttribute("SignalR does not currently support trimming or native AOT.", Url="https://aka.ms/aspnet/trimming")]
+-        public static ISignalRServerBuilder AddSignalR(this IServiceCollection services);
++        public static ISignalRServerBuilder AddSignalR(this IServiceCollection services);
+-        [RequiresUnreferencedCodeAttribute("SignalR does not currently support trimming or native AOT.", Url="https://aka.ms/aspnet/trimming")]
+-        public static ISignalRServerBuilder AddSignalR(this IServiceCollection services, Action<HubOptions> configure);
++        public static ISignalRServerBuilder AddSignalR(this IServiceCollection services, Action<HubOptions> configure);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.AspNetCore.App/9.0-preview7_Microsoft.Extensions.Logging.Abstractions.md

@@ -0,0 +1,23 @@
+# Microsoft.Extensions.Logging.Abstractions
+
+``` diff
+ namespace Microsoft.Extensions.Logging.Abstractions {
++    public abstract class BufferedLogRecord {
++        protected BufferedLogRecord();
++        public virtual ActivitySpanId? ActivitySpanId { get; }
++        public virtual ActivityTraceId? ActivityTraceId { get; }
++        public virtual IReadOnlyList<KeyValuePair<string, object?>> Attributes { get; }
++        public abstract EventId EventId { get; }
++        public virtual string Exception { get; }
++        public virtual string FormattedMessage { get; }
++        public abstract LogLevel LogLevel { get; }
++        public virtual int? ManagedThreadId { get; }
++        public virtual string MessageTemplate { get; }
++        public abstract DateTimeOffset Timestamp { get; }
++    }
++    public interface IBufferedLogger {
++        void LogRecords(IEnumerable<BufferedLogRecord> records);
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7.md

@@ -0,0 +1,23 @@
+# API Difference 9.0-preview6 vs 9.0-preview7
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [System](9.0-preview7_System.md)
+* [System.Data](9.0-preview7_System.Data.md)
+* [System.Diagnostics](9.0-preview7_System.Diagnostics.md)
+* [System.Diagnostics.Metrics](9.0-preview7_System.Diagnostics.Metrics.md)
+* [System.Formats.Tar](9.0-preview7_System.Formats.Tar.md)
+* [System.Net.Http](9.0-preview7_System.Net.Http.md)
+* [System.Net.Quic](9.0-preview7_System.Net.Quic.md)
+* [System.Numerics](9.0-preview7_System.Numerics.md)
+* [System.Runtime.InteropServices](9.0-preview7_System.Runtime.InteropServices.md)
+* [System.Runtime.Intrinsics](9.0-preview7_System.Runtime.Intrinsics.md)
+* [System.Runtime.Intrinsics.Arm](9.0-preview7_System.Runtime.Intrinsics.Arm.md)
+* [System.Security.Cryptography](9.0-preview7_System.Security.Cryptography.md)
+* [System.Security.Cryptography.X509Certificates](9.0-preview7_System.Security.Cryptography.X509Certificates.md)
+* [System.Text.Json](9.0-preview7_System.Text.Json.md)
+* [System.Text.Json.Schema](9.0-preview7_System.Text.Json.Schema.md)
+* [System.Text.Json.Serialization](9.0-preview7_System.Text.Json.Serialization.md)
+* [System.Threading](9.0-preview7_System.Threading.md)
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Data.md

@@ -0,0 +1,10 @@
+# System.Data
+
+``` diff
+ namespace System.Data {
+     public enum SqlDbType {
++        Json = 35,
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Diagnostics.Metrics.md

@@ -0,0 +1,10 @@
+# System.Diagnostics.Metrics
+
+``` diff
+ namespace System.Diagnostics.Metrics {
+     public readonly struct Measurement<T> where T : struct {
++        public Measurement(T value, in TagList tags);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Diagnostics.md

@@ -0,0 +1,36 @@
+# System.Diagnostics
+
+``` diff
+ namespace System.Diagnostics {
+     public static class Debug {
+-        [ConditionalAttribute("DEBUG")]
+-        public static void Assert([DoesNotReturnIfAttribute(false)] bool condition);
++        [ConditionalAttribute("DEBUG")]
++        [OverloadResolutionPriorityAttribute(-1)]
++        public static void Assert([DoesNotReturnIfAttribute(false)] bool condition);
+-        [ConditionalAttribute("DEBUG")]
+-        public static void Assert([DoesNotReturnIfAttribute(false)] bool condition, string message);
++        [ConditionalAttribute("DEBUG")]
++        public static void Assert([DoesNotReturnIfAttribute(false)] bool condition, [CallerArgumentExpressionAttribute("condition")] string message = null);
+     }
+     public static class Debugger {
++        public static void BreakForUserUnhandledException(Exception exception);
+     }
++    [AttributeUsageAttribute(AttributeTargets.Method)]
++    public sealed class DebuggerDisableUserUnhandledExceptionsAttribute : Attribute {
++        public DebuggerDisableUserUnhandledExceptionsAttribute();
++    }
+     public sealed class Trace {
+-        [ConditionalAttribute("TRACE")]
+-        public static void Assert([DoesNotReturnIfAttribute(false)] bool condition);
++        [ConditionalAttribute("TRACE")]
++        [OverloadResolutionPriorityAttribute(-1)]
++        public static void Assert([DoesNotReturnIfAttribute(false)] bool condition);
+-        [ConditionalAttribute("TRACE")]
+-        public static void Assert([DoesNotReturnIfAttribute(false)] bool condition, string message);
++        [ConditionalAttribute("TRACE")]
++        public static void Assert([DoesNotReturnIfAttribute(false)] bool condition, [CallerArgumentExpressionAttribute("condition")] string message = null);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Formats.Tar.md

@@ -0,0 +1,10 @@
+# System.Formats.Tar
+
+``` diff
+ namespace System.Formats.Tar {
+     public abstract class TarEntry {
++        public long DataOffset { get; }
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Net.Http.md

@@ -0,0 +1,15 @@
+# System.Net.Http
+
+``` diff
+ namespace System.Net.Http {
+     public abstract class HttpContent : IDisposable {
++        public Task LoadIntoBufferAsync(long maxBufferSize, CancellationToken cancellationToken);
++        public Task LoadIntoBufferAsync(CancellationToken cancellationToken);
+     }
+     [UnsupportedOSPlatformAttribute("browser")]
+     public sealed class SocketsHttpHandler : HttpMessageHandler {
++        public bool EnableMultipleHttp3Connections { get; set; }
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Net.Quic.md

@@ -0,0 +1,14 @@
+# System.Net.Quic
+
+``` diff
+ namespace System.Net.Quic {
+     public abstract class QuicConnectionOptions {
++        public Action<QuicConnection, QuicStreamCapacityChangedArgs>? StreamCapacityCallback { get; set; }
+     }
++    public readonly struct QuicStreamCapacityChangedArgs {
++        public int BidirectionalIncrement { get; set; }
++        public int UnidirectionalIncrement { get; set; }
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Numerics.md

@@ -0,0 +1,150 @@
+# System.Numerics
+
+``` diff
+ namespace System.Numerics {
+     public static class Vector {
++        public static Vector<T> Clamp<T>(Vector<T> value, Vector<T> min, Vector<T> max);
++        public static Vector<T> ClampNative<T>(Vector<T> value, Vector<T> min, Vector<T> max);
++        public static Vector<T> CopySign<T>(Vector<T> value, Vector<T> sign);
++        public static Vector<double> Cos(Vector<double> vector);
++        public static Vector<float> Cos(Vector<float> vector);
++        public static Vector<double> DegreesToRadians(Vector<double> degrees);
++        public static Vector<float> DegreesToRadians(Vector<float> degrees);
++        public static Vector<double> Exp(Vector<double> vector);
++        public static Vector<float> Exp(Vector<float> vector);
++        public static Vector<double> Hypot(Vector<double> x, Vector<double> y);
++        public static Vector<float> Hypot(Vector<float> x, Vector<float> y);
++        public static Vector<T> IsNaN<T>(Vector<T> vector);
++        public static Vector<T> IsNegative<T>(Vector<T> vector);
++        public static Vector<T> IsPositive<T>(Vector<T> vector);
++        public static Vector<T> IsPositiveInfinity<T>(Vector<T> vector);
++        public static Vector<T> IsZero<T>(Vector<T> vector);
++        public static Vector<double> Lerp(Vector<double> x, Vector<double> y, Vector<double> amount);
++        public static Vector<float> Lerp(Vector<float> x, Vector<float> y, Vector<float> amount);
++        public static Vector<double> Log(Vector<double> vector);
++        public static Vector<float> Log(Vector<float> vector);
++        public static Vector<double> Log2(Vector<double> vector);
++        public static Vector<float> Log2(Vector<float> vector);
++        public static Vector<T> MaxMagnitude<T>(Vector<T> left, Vector<T> right);
++        public static Vector<T> MaxMagnitudeNumber<T>(Vector<T> left, Vector<T> right);
++        public static Vector<T> MaxNative<T>(Vector<T> left, Vector<T> right);
++        public static Vector<T> MaxNumber<T>(Vector<T> left, Vector<T> right);
++        public static Vector<T> MinMagnitude<T>(Vector<T> left, Vector<T> right);
++        public static Vector<T> MinMagnitudeNumber<T>(Vector<T> left, Vector<T> right);
++        public static Vector<T> MinNative<T>(Vector<T> left, Vector<T> right);
++        public static Vector<T> MinNumber<T>(Vector<T> left, Vector<T> right);
++        public static Vector<double> RadiansToDegrees(Vector<double> radians);
++        public static Vector<float> RadiansToDegrees(Vector<float> radians);
++        public static Vector<double> Round(Vector<double> vector);
++        public static Vector<double> Round(Vector<double> vector, MidpointRounding mode);
++        public static Vector<float> Round(Vector<float> vector);
++        public static Vector<float> Round(Vector<float> vector, MidpointRounding mode);
++        public static Vector<double> Sin(Vector<double> vector);
++        public static Vector<float> Sin(Vector<float> vector);
++        public static (Vector<double> Sin, Vector<double> Cos) SinCos(Vector<double> vector);
++        public static (Vector<float> Sin, Vector<float> Cos) SinCos(Vector<float> vector);
++        public static Vector<double> Truncate(Vector<double> vector);
++        public static Vector<float> Truncate(Vector<float> vector);
+     }
+     public struct Vector2 : IEquatable<Vector2>, IFormattable {
++        public static Vector2 E { get; }
++        public static Vector2 Epsilon { get; }
++        public static Vector2 NaN { get; }
++        public static Vector2 NegativeInfinity { get; }
++        public static Vector2 NegativeZero { get; }
++        public static Vector2 Pi { get; }
++        public static Vector2 PositiveInfinity { get; }
++        public static Vector2 Tau { get; }
++        public static Vector2 ClampNative(Vector2 value1, Vector2 min, Vector2 max);
++        public static Vector2 CopySign(Vector2 value, Vector2 sign);
++        public static Vector2 Cos(Vector2 vector);
++        public static Vector2 DegreesToRadians(Vector2 degrees);
++        public static Vector2 Exp(Vector2 vector);
++        public static Vector2 Hypot(Vector2 x, Vector2 y);
++        public static Vector2 Lerp(Vector2 value1, Vector2 value2, Vector2 amount);
++        public static Vector2 Log(Vector2 vector);
++        public static Vector2 Log2(Vector2 vector);
++        public static Vector2 MaxMagnitude(Vector2 value1, Vector2 value2);
++        public static Vector2 MaxMagnitudeNumber(Vector2 value1, Vector2 value2);
++        public static Vector2 MaxNative(Vector2 value1, Vector2 value2);
++        public static Vector2 MaxNumber(Vector2 value1, Vector2 value2);
++        public static Vector2 MinMagnitude(Vector2 value1, Vector2 value2);
++        public static Vector2 MinMagnitudeNumber(Vector2 value1, Vector2 value2);
++        public static Vector2 MinNative(Vector2 value1, Vector2 value2);
++        public static Vector2 MinNumber(Vector2 value1, Vector2 value2);
++        public static Vector2 RadiansToDegrees(Vector2 radians);
++        public static Vector2 Round(Vector2 vector);
++        public static Vector2 Round(Vector2 vector, MidpointRounding mode);
++        public static Vector2 Sin(Vector2 vector);
++        public static (Vector2 Sin, Vector2 Cos) SinCos(Vector2 vector);
++        public static Vector2 Truncate(Vector2 vector);
+     }
+     public struct Vector3 : IEquatable<Vector3>, IFormattable {
++        public static Vector3 E { get; }
++        public static Vector3 Epsilon { get; }
++        public static Vector3 NaN { get; }
++        public static Vector3 NegativeInfinity { get; }
++        public static Vector3 NegativeZero { get; }
++        public static Vector3 Pi { get; }
++        public static Vector3 PositiveInfinity { get; }
++        public static Vector3 Tau { get; }
++        public static Vector3 ClampNative(Vector3 value1, Vector3 min, Vector3 max);
++        public static Vector3 CopySign(Vector3 value, Vector3 sign);
++        public static Vector3 Cos(Vector3 vector);
++        public static Vector3 DegreesToRadians(Vector3 degrees);
++        public static Vector3 Exp(Vector3 vector);
++        public static Vector3 Hypot(Vector3 x, Vector3 y);
++        public static Vector3 Lerp(Vector3 value1, Vector3 value2, Vector3 amount);
++        public static Vector3 Log(Vector3 vector);
++        public static Vector3 Log2(Vector3 vector);
++        public static Vector3 MaxMagnitude(Vector3 value1, Vector3 value2);
++        public static Vector3 MaxMagnitudeNumber(Vector3 value1, Vector3 value2);
++        public static Vector3 MaxNative(Vector3 value1, Vector3 value2);
++        public static Vector3 MaxNumber(Vector3 value1, Vector3 value2);
++        public static Vector3 MinMagnitude(Vector3 value1, Vector3 value2);
++        public static Vector3 MinMagnitudeNumber(Vector3 value1, Vector3 value2);
++        public static Vector3 MinNative(Vector3 value1, Vector3 value2);
++        public static Vector3 MinNumber(Vector3 value1, Vector3 value2);
++        public static Vector3 RadiansToDegrees(Vector3 radians);
++        public static Vector3 Round(Vector3 vector);
++        public static Vector3 Round(Vector3 vector, MidpointRounding mode);
++        public static Vector3 Sin(Vector3 vector);
++        public static (Vector3 Sin, Vector3 Cos) SinCos(Vector3 vector);
++        public static Vector3 Truncate(Vector3 vector);
+     }
+     public struct Vector4 : IEquatable<Vector4>, IFormattable {
++        public static Vector4 E { get; }
++        public static Vector4 Epsilon { get; }
++        public static Vector4 NaN { get; }
++        public static Vector4 NegativeInfinity { get; }
++        public static Vector4 NegativeZero { get; }
++        public static Vector4 Pi { get; }
++        public static Vector4 PositiveInfinity { get; }
++        public static Vector4 Tau { get; }
++        public static Vector4 ClampNative(Vector4 value1, Vector4 min, Vector4 max);
++        public static Vector4 CopySign(Vector4 value, Vector4 sign);
++        public static Vector4 Cos(Vector4 vector);
++        public static Vector4 DegreesToRadians(Vector4 degrees);
++        public static Vector4 Exp(Vector4 vector);
++        public static Vector4 Hypot(Vector4 x, Vector4 y);
++        public static Vector4 Lerp(Vector4 value1, Vector4 value2, Vector4 amount);
++        public static Vector4 Log(Vector4 vector);
++        public static Vector4 Log2(Vector4 vector);
++        public static Vector4 MaxMagnitude(Vector4 value1, Vector4 value2);
++        public static Vector4 MaxMagnitudeNumber(Vector4 value1, Vector4 value2);
++        public static Vector4 MaxNative(Vector4 value1, Vector4 value2);
++        public static Vector4 MaxNumber(Vector4 value1, Vector4 value2);
++        public static Vector4 MinMagnitude(Vector4 value1, Vector4 value2);
++        public static Vector4 MinMagnitudeNumber(Vector4 value1, Vector4 value2);
++        public static Vector4 MinNative(Vector4 value1, Vector4 value2);
++        public static Vector4 MinNumber(Vector4 value1, Vector4 value2);
++        public static Vector4 RadiansToDegrees(Vector4 radians);
++        public static Vector4 Round(Vector4 vector);
++        public static Vector4 Round(Vector4 vector, MidpointRounding mode);
++        public static Vector4 Sin(Vector4 vector);
++        public static (Vector4 Sin, Vector4 Cos) SinCos(Vector4 vector);
++        public static Vector4 Truncate(Vector4 vector);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Runtime.InteropServices.md

@@ -0,0 +1,10 @@
+# System.Runtime.InteropServices
+
+``` diff
+ namespace System.Runtime.InteropServices {
++    public static class JsonMarshal {
++        public static ReadOnlySpan<byte> GetRawUtf8Value(JsonElement element);
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Runtime.Intrinsics.Arm.md

@@ -0,0 +1,477 @@
+# System.Runtime.Intrinsics.Arm
+
+``` diff
+ namespace System.Runtime.Intrinsics.Arm {
+     [CLSCompliantAttribute(false)]
+     [RequiresPreviewFeaturesAttribute("Sve is in preview. Debugger scenario is not supported.")]
+     public abstract class Sve : AdvSimd {
++        public static Vector<double> AbsoluteCompareGreaterThan(Vector<double> left, Vector<double> right);
++        public static Vector<float> AbsoluteCompareGreaterThan(Vector<float> left, Vector<float> right);
++        public static Vector<double> AbsoluteCompareGreaterThanOrEqual(Vector<double> left, Vector<double> right);
++        public static Vector<float> AbsoluteCompareGreaterThanOrEqual(Vector<float> left, Vector<float> right);
++        public static Vector<double> AbsoluteCompareLessThan(Vector<double> left, Vector<double> right);
++        public static Vector<float> AbsoluteCompareLessThan(Vector<float> left, Vector<float> right);
++        public static Vector<double> AbsoluteCompareLessThanOrEqual(Vector<double> left, Vector<double> right);
++        public static Vector<float> AbsoluteCompareLessThanOrEqual(Vector<float> left, Vector<float> right);
++        public static Vector<double> AddRotateComplex(Vector<double> left, Vector<double> right, [ConstantExpectedAttribute(Min=0, Max=(byte)1)] byte rotation);
++        public static Vector<float> AddRotateComplex(Vector<float> left, Vector<float> right, [ConstantExpectedAttribute(Min=0, Max=(byte)1)] byte rotation);
++        public static Vector<double> AddSequentialAcross(Vector<double> initial, Vector<double> value);
++        public static Vector<float> AddSequentialAcross(Vector<float> initial, Vector<float> value);
++        public static Vector<byte> CompareEqual(Vector<byte> left, Vector<byte> right);
++        public static Vector<double> CompareEqual(Vector<double> left, Vector<double> right);
++        public static Vector<short> CompareEqual(Vector<short> left, Vector<short> right);
++        public static Vector<short> CompareEqual(Vector<short> left, Vector<long> right);
++        public static Vector<int> CompareEqual(Vector<int> left, Vector<int> right);
++        public static Vector<int> CompareEqual(Vector<int> left, Vector<long> right);
++        public static Vector<long> CompareEqual(Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> CompareEqual(Vector<sbyte> left, Vector<long> right);
++        public static Vector<sbyte> CompareEqual(Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> CompareEqual(Vector<float> left, Vector<float> right);
++        public static Vector<ushort> CompareEqual(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<uint> CompareEqual(Vector<uint> left, Vector<uint> right);
++        public static Vector<ulong> CompareEqual(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> CompareGreaterThan(Vector<byte> left, Vector<byte> right);
++        public static Vector<byte> CompareGreaterThan(Vector<byte> left, Vector<ulong> right);
++        public static Vector<double> CompareGreaterThan(Vector<double> left, Vector<double> right);
++        public static Vector<short> CompareGreaterThan(Vector<short> left, Vector<short> right);
++        public static Vector<short> CompareGreaterThan(Vector<short> left, Vector<long> right);
++        public static Vector<int> CompareGreaterThan(Vector<int> left, Vector<int> right);
++        public static Vector<int> CompareGreaterThan(Vector<int> left, Vector<long> right);
++        public static Vector<long> CompareGreaterThan(Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, Vector<long> right);
++        public static Vector<sbyte> CompareGreaterThan(Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> CompareGreaterThan(Vector<float> left, Vector<float> right);
++        public static Vector<ushort> CompareGreaterThan(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<ushort> CompareGreaterThan(Vector<ushort> left, Vector<ulong> right);
++        public static Vector<uint> CompareGreaterThan(Vector<uint> left, Vector<uint> right);
++        public static Vector<uint> CompareGreaterThan(Vector<uint> left, Vector<ulong> right);
++        public static Vector<ulong> CompareGreaterThan(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, Vector<byte> right);
++        public static Vector<byte> CompareGreaterThanOrEqual(Vector<byte> left, Vector<ulong> right);
++        public static Vector<double> CompareGreaterThanOrEqual(Vector<double> left, Vector<double> right);
++        public static Vector<short> CompareGreaterThanOrEqual(Vector<short> left, Vector<short> right);
++        public static Vector<short> CompareGreaterThanOrEqual(Vector<short> left, Vector<long> right);
++        public static Vector<int> CompareGreaterThanOrEqual(Vector<int> left, Vector<int> right);
++        public static Vector<int> CompareGreaterThanOrEqual(Vector<int> left, Vector<long> right);
++        public static Vector<long> CompareGreaterThanOrEqual(Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, Vector<long> right);
++        public static Vector<sbyte> CompareGreaterThanOrEqual(Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> CompareGreaterThanOrEqual(Vector<float> left, Vector<float> right);
++        public static Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<ushort> CompareGreaterThanOrEqual(Vector<ushort> left, Vector<ulong> right);
++        public static Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, Vector<uint> right);
++        public static Vector<uint> CompareGreaterThanOrEqual(Vector<uint> left, Vector<ulong> right);
++        public static Vector<ulong> CompareGreaterThanOrEqual(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> CompareLessThan(Vector<byte> left, Vector<byte> right);
++        public static Vector<byte> CompareLessThan(Vector<byte> left, Vector<ulong> right);
++        public static Vector<double> CompareLessThan(Vector<double> left, Vector<double> right);
++        public static Vector<short> CompareLessThan(Vector<short> left, Vector<short> right);
++        public static Vector<short> CompareLessThan(Vector<short> left, Vector<long> right);
++        public static Vector<int> CompareLessThan(Vector<int> left, Vector<int> right);
++        public static Vector<int> CompareLessThan(Vector<int> left, Vector<long> right);
++        public static Vector<long> CompareLessThan(Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> CompareLessThan(Vector<sbyte> left, Vector<long> right);
++        public static Vector<sbyte> CompareLessThan(Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> CompareLessThan(Vector<float> left, Vector<float> right);
++        public static Vector<ushort> CompareLessThan(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<ushort> CompareLessThan(Vector<ushort> left, Vector<ulong> right);
++        public static Vector<uint> CompareLessThan(Vector<uint> left, Vector<uint> right);
++        public static Vector<uint> CompareLessThan(Vector<uint> left, Vector<ulong> right);
++        public static Vector<ulong> CompareLessThan(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> CompareLessThanOrEqual(Vector<byte> left, Vector<byte> right);
++        public static Vector<byte> CompareLessThanOrEqual(Vector<byte> left, Vector<ulong> right);
++        public static Vector<double> CompareLessThanOrEqual(Vector<double> left, Vector<double> right);
++        public static Vector<short> CompareLessThanOrEqual(Vector<short> left, Vector<short> right);
++        public static Vector<short> CompareLessThanOrEqual(Vector<short> left, Vector<long> right);
++        public static Vector<int> CompareLessThanOrEqual(Vector<int> left, Vector<int> right);
++        public static Vector<int> CompareLessThanOrEqual(Vector<int> left, Vector<long> right);
++        public static Vector<long> CompareLessThanOrEqual(Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, Vector<long> right);
++        public static Vector<sbyte> CompareLessThanOrEqual(Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> CompareLessThanOrEqual(Vector<float> left, Vector<float> right);
++        public static Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<ushort> CompareLessThanOrEqual(Vector<ushort> left, Vector<ulong> right);
++        public static Vector<uint> CompareLessThanOrEqual(Vector<uint> left, Vector<uint> right);
++        public static Vector<uint> CompareLessThanOrEqual(Vector<uint> left, Vector<ulong> right);
++        public static Vector<ulong> CompareLessThanOrEqual(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> CompareNotEqualTo(Vector<byte> left, Vector<byte> right);
++        public static Vector<double> CompareNotEqualTo(Vector<double> left, Vector<double> right);
++        public static Vector<short> CompareNotEqualTo(Vector<short> left, Vector<short> right);
++        public static Vector<short> CompareNotEqualTo(Vector<short> left, Vector<long> right);
++        public static Vector<int> CompareNotEqualTo(Vector<int> left, Vector<int> right);
++        public static Vector<int> CompareNotEqualTo(Vector<int> left, Vector<long> right);
++        public static Vector<long> CompareNotEqualTo(Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, Vector<long> right);
++        public static Vector<sbyte> CompareNotEqualTo(Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> CompareNotEqualTo(Vector<float> left, Vector<float> right);
++        public static Vector<ushort> CompareNotEqualTo(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<uint> CompareNotEqualTo(Vector<uint> left, Vector<uint> right);
++        public static Vector<ulong> CompareNotEqualTo(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<double> CompareUnordered(Vector<double> left, Vector<double> right);
++        public static Vector<float> CompareUnordered(Vector<float> left, Vector<float> right);
++        public static byte ConditionalExtractAfterLastActiveElement(Vector<byte> mask, byte defaultValues, Vector<byte> data);
++        public static Vector<byte> ConditionalExtractAfterLastActiveElement(Vector<byte> mask, Vector<byte> defaultValue, Vector<byte> data);
++        public static double ConditionalExtractAfterLastActiveElement(Vector<double> mask, double defaultValues, Vector<double> data);
++        public static Vector<double> ConditionalExtractAfterLastActiveElement(Vector<double> mask, Vector<double> defaultValue, Vector<double> data);
++        public static short ConditionalExtractAfterLastActiveElement(Vector<short> mask, short defaultValues, Vector<short> data);
++        public static Vector<short> ConditionalExtractAfterLastActiveElement(Vector<short> mask, Vector<short> defaultValue, Vector<short> data);
++        public static int ConditionalExtractAfterLastActiveElement(Vector<int> mask, int defaultValues, Vector<int> data);
++        public static Vector<int> ConditionalExtractAfterLastActiveElement(Vector<int> mask, Vector<int> defaultValue, Vector<int> data);
++        public static long ConditionalExtractAfterLastActiveElement(Vector<long> mask, long defaultValues, Vector<long> data);
++        public static Vector<long> ConditionalExtractAfterLastActiveElement(Vector<long> mask, Vector<long> defaultValue, Vector<long> data);
++        public static Vector<sbyte> ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, Vector<sbyte> defaultValue, Vector<sbyte> data);
++        public static sbyte ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, sbyte defaultValues, Vector<sbyte> data);
++        public static Vector<float> ConditionalExtractAfterLastActiveElement(Vector<float> mask, Vector<float> defaultValue, Vector<float> data);
++        public static float ConditionalExtractAfterLastActiveElement(Vector<float> mask, float defaultValues, Vector<float> data);
++        public static Vector<ushort> ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, Vector<ushort> defaultValue, Vector<ushort> data);
++        public static ushort ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, ushort defaultValues, Vector<ushort> data);
++        public static Vector<uint> ConditionalExtractAfterLastActiveElement(Vector<uint> mask, Vector<uint> defaultValue, Vector<uint> data);
++        public static uint ConditionalExtractAfterLastActiveElement(Vector<uint> mask, uint defaultValues, Vector<uint> data);
++        public static Vector<ulong> ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, Vector<ulong> defaultValue, Vector<ulong> data);
++        public static ulong ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, ulong defaultValues, Vector<ulong> data);
++        public static Vector<byte> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<byte> mask, Vector<byte> defaultScalar, Vector<byte> data);
++        public static Vector<double> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<double> mask, Vector<double> defaultScalar, Vector<double> data);
++        public static Vector<short> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<short> mask, Vector<short> defaultScalar, Vector<short> data);
++        public static Vector<int> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<int> mask, Vector<int> defaultScalar, Vector<int> data);
++        public static Vector<long> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<long> mask, Vector<long> defaultScalar, Vector<long> data);
++        public static Vector<sbyte> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<sbyte> mask, Vector<sbyte> defaultScalar, Vector<sbyte> data);
++        public static Vector<float> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<float> mask, Vector<float> defaultScalar, Vector<float> data);
++        public static Vector<ushort> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<ushort> mask, Vector<ushort> defaultScalar, Vector<ushort> data);
++        public static Vector<uint> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<uint> mask, Vector<uint> defaultScalar, Vector<uint> data);
++        public static Vector<ulong> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<ulong> mask, Vector<ulong> defaultScalar, Vector<ulong> data);
++        public static byte ConditionalExtractLastActiveElement(Vector<byte> mask, byte defaultValues, Vector<byte> data);
++        public static Vector<byte> ConditionalExtractLastActiveElement(Vector<byte> mask, Vector<byte> defaultValue, Vector<byte> data);
++        public static double ConditionalExtractLastActiveElement(Vector<double> mask, double defaultValues, Vector<double> data);
++        public static Vector<double> ConditionalExtractLastActiveElement(Vector<double> mask, Vector<double> defaultValue, Vector<double> data);
++        public static short ConditionalExtractLastActiveElement(Vector<short> mask, short defaultValues, Vector<short> data);
++        public static Vector<short> ConditionalExtractLastActiveElement(Vector<short> mask, Vector<short> defaultValue, Vector<short> data);
++        public static int ConditionalExtractLastActiveElement(Vector<int> mask, int defaultValues, Vector<int> data);
++        public static Vector<int> ConditionalExtractLastActiveElement(Vector<int> mask, Vector<int> defaultValue, Vector<int> data);
++        public static long ConditionalExtractLastActiveElement(Vector<long> mask, long defaultValues, Vector<long> data);
++        public static Vector<long> ConditionalExtractLastActiveElement(Vector<long> mask, Vector<long> defaultValue, Vector<long> data);
++        public static Vector<sbyte> ConditionalExtractLastActiveElement(Vector<sbyte> mask, Vector<sbyte> defaultValue, Vector<sbyte> data);
++        public static sbyte ConditionalExtractLastActiveElement(Vector<sbyte> mask, sbyte defaultValues, Vector<sbyte> data);
++        public static Vector<float> ConditionalExtractLastActiveElement(Vector<float> mask, Vector<float> defaultValue, Vector<float> data);
++        public static float ConditionalExtractLastActiveElement(Vector<float> mask, float defaultValues, Vector<float> data);
++        public static Vector<ushort> ConditionalExtractLastActiveElement(Vector<ushort> mask, Vector<ushort> defaultValue, Vector<ushort> data);
++        public static ushort ConditionalExtractLastActiveElement(Vector<ushort> mask, ushort defaultValues, Vector<ushort> data);
++        public static Vector<uint> ConditionalExtractLastActiveElement(Vector<uint> mask, Vector<uint> defaultValue, Vector<uint> data);
++        public static uint ConditionalExtractLastActiveElement(Vector<uint> mask, uint defaultValues, Vector<uint> data);
++        public static Vector<ulong> ConditionalExtractLastActiveElement(Vector<ulong> mask, Vector<ulong> defaultValue, Vector<ulong> data);
++        public static ulong ConditionalExtractLastActiveElement(Vector<ulong> mask, ulong defaultValues, Vector<ulong> data);
++        public static Vector<byte> ConditionalExtractLastActiveElementAndReplicate(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data);
++        public static Vector<double> ConditionalExtractLastActiveElementAndReplicate(Vector<double> mask, Vector<double> fallback, Vector<double> data);
++        public static Vector<short> ConditionalExtractLastActiveElementAndReplicate(Vector<short> mask, Vector<short> fallback, Vector<short> data);
++        public static Vector<int> ConditionalExtractLastActiveElementAndReplicate(Vector<int> mask, Vector<int> fallback, Vector<int> data);
++        public static Vector<long> ConditionalExtractLastActiveElementAndReplicate(Vector<long> mask, Vector<long> fallback, Vector<long> data);
++        public static Vector<sbyte> ConditionalExtractLastActiveElementAndReplicate(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data);
++        public static Vector<float> ConditionalExtractLastActiveElementAndReplicate(Vector<float> mask, Vector<float> fallback, Vector<float> data);
++        public static Vector<ushort> ConditionalExtractLastActiveElementAndReplicate(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data);
++        public static Vector<uint> ConditionalExtractLastActiveElementAndReplicate(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data);
++        public static Vector<ulong> ConditionalExtractLastActiveElementAndReplicate(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data);
++        public static Vector<double> ConvertToDouble(Vector<int> value);
++        public static Vector<double> ConvertToDouble(Vector<long> value);
++        public static Vector<double> ConvertToDouble(Vector<float> value);
++        public static Vector<double> ConvertToDouble(Vector<uint> value);
++        public static Vector<double> ConvertToDouble(Vector<ulong> value);
++        public static Vector<long> ConvertToInt64(Vector<double> value);
++        public static Vector<long> ConvertToInt64(Vector<float> value);
++        public static Vector<float> ConvertToSingle(Vector<double> value);
++        public static Vector<float> ConvertToSingle(Vector<int> value);
++        public static Vector<float> ConvertToSingle(Vector<long> value);
++        public static Vector<float> ConvertToSingle(Vector<uint> value);
++        public static Vector<float> ConvertToSingle(Vector<ulong> value);
++        public static Vector<ulong> ConvertToUInt64(Vector<double> value);
++        public static Vector<ulong> ConvertToUInt64(Vector<float> value);
++        public static Vector<byte> CreateBreakAfterMask(Vector<byte> mask, Vector<byte> srcMask);
++        public static Vector<short> CreateBreakAfterMask(Vector<short> mask, Vector<short> srcMask);
++        public static Vector<int> CreateBreakAfterMask(Vector<int> mask, Vector<int> srcMask);
++        public static Vector<long> CreateBreakAfterMask(Vector<long> mask, Vector<long> srcMask);
++        public static Vector<sbyte> CreateBreakAfterMask(Vector<sbyte> mask, Vector<sbyte> srcMask);
++        public static Vector<ushort> CreateBreakAfterMask(Vector<ushort> mask, Vector<ushort> srcMask);
++        public static Vector<uint> CreateBreakAfterMask(Vector<uint> mask, Vector<uint> srcMask);
++        public static Vector<ulong> CreateBreakAfterMask(Vector<ulong> mask, Vector<ulong> srcMask);
++        public static Vector<byte> CreateBreakAfterPropagateMask(Vector<byte> mask, Vector<byte> left, Vector<byte> right);
++        public static Vector<short> CreateBreakAfterPropagateMask(Vector<short> mask, Vector<short> left, Vector<short> right);
++        public static Vector<int> CreateBreakAfterPropagateMask(Vector<int> mask, Vector<int> left, Vector<int> right);
++        public static Vector<long> CreateBreakAfterPropagateMask(Vector<long> mask, Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> CreateBreakAfterPropagateMask(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<ushort> CreateBreakAfterPropagateMask(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);
++        public static Vector<uint> CreateBreakAfterPropagateMask(Vector<uint> mask, Vector<uint> left, Vector<uint> right);
++        public static Vector<ulong> CreateBreakAfterPropagateMask(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> CreateBreakBeforeMask(Vector<byte> mask, Vector<byte> srcMask);
++        public static Vector<short> CreateBreakBeforeMask(Vector<short> mask, Vector<short> srcMask);
++        public static Vector<int> CreateBreakBeforeMask(Vector<int> mask, Vector<int> srcMask);
++        public static Vector<long> CreateBreakBeforeMask(Vector<long> mask, Vector<long> srcMask);
++        public static Vector<sbyte> CreateBreakBeforeMask(Vector<sbyte> mask, Vector<sbyte> srcMask);
++        public static Vector<ushort> CreateBreakBeforeMask(Vector<ushort> mask, Vector<ushort> srcMask);
++        public static Vector<uint> CreateBreakBeforeMask(Vector<uint> mask, Vector<uint> srcMask);
++        public static Vector<ulong> CreateBreakBeforeMask(Vector<ulong> mask, Vector<ulong> srcMask);
++        public static Vector<byte> CreateBreakBeforePropagateMask(Vector<byte> mask, Vector<byte> left, Vector<byte> right);
++        public static Vector<short> CreateBreakBeforePropagateMask(Vector<short> mask, Vector<short> left, Vector<short> right);
++        public static Vector<int> CreateBreakBeforePropagateMask(Vector<int> mask, Vector<int> left, Vector<int> right);
++        public static Vector<long> CreateBreakBeforePropagateMask(Vector<long> mask, Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> CreateBreakBeforePropagateMask(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<ushort> CreateBreakBeforePropagateMask(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);
++        public static Vector<uint> CreateBreakBeforePropagateMask(Vector<uint> mask, Vector<uint> left, Vector<uint> right);
++        public static Vector<ulong> CreateBreakBeforePropagateMask(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> CreateBreakPropagateMask(Vector<byte> totalMask, Vector<byte> fromMask);
++        public static Vector<short> CreateBreakPropagateMask(Vector<short> totalMask, Vector<short> fromMask);
++        public static Vector<int> CreateBreakPropagateMask(Vector<int> totalMask, Vector<int> fromMask);
++        public static Vector<long> CreateBreakPropagateMask(Vector<long> totalMask, Vector<long> fromMask);
++        public static Vector<sbyte> CreateBreakPropagateMask(Vector<sbyte> totalMask, Vector<sbyte> fromMask);
++        public static Vector<ushort> CreateBreakPropagateMask(Vector<ushort> totalMask, Vector<ushort> fromMask);
++        public static Vector<uint> CreateBreakPropagateMask(Vector<uint> totalMask, Vector<uint> fromMask);
++        public static Vector<ulong> CreateBreakPropagateMask(Vector<ulong> totalMask, Vector<ulong> fromMask);
++        public static Vector<byte> CreateMaskForFirstActiveElement(Vector<byte> mask, Vector<byte> srcMask);
++        public static Vector<short> CreateMaskForFirstActiveElement(Vector<short> mask, Vector<short> srcMask);
++        public static Vector<int> CreateMaskForFirstActiveElement(Vector<int> mask, Vector<int> srcMask);
++        public static Vector<long> CreateMaskForFirstActiveElement(Vector<long> mask, Vector<long> srcMask);
++        public static Vector<sbyte> CreateMaskForFirstActiveElement(Vector<sbyte> mask, Vector<sbyte> srcMask);
++        public static Vector<ushort> CreateMaskForFirstActiveElement(Vector<ushort> mask, Vector<ushort> srcMask);
++        public static Vector<uint> CreateMaskForFirstActiveElement(Vector<uint> mask, Vector<uint> srcMask);
++        public static Vector<ulong> CreateMaskForFirstActiveElement(Vector<ulong> mask, Vector<ulong> srcMask);
++        public static Vector<byte> CreateMaskForNextActiveElement(Vector<byte> mask, Vector<byte> srcMask);
++        public static Vector<ushort> CreateMaskForNextActiveElement(Vector<ushort> mask, Vector<ushort> srcMask);
++        public static Vector<uint> CreateMaskForNextActiveElement(Vector<uint> mask, Vector<uint> srcMask);
++        public static Vector<ulong> CreateMaskForNextActiveElement(Vector<ulong> mask, Vector<ulong> srcMask);
++        public static Vector<byte> DuplicateSelectedScalarToVector(Vector<byte> data, [ConstantExpectedAttribute(Min=0, Max=(byte)63)] byte index);
++        public static Vector<double> DuplicateSelectedScalarToVector(Vector<double> data, [ConstantExpectedAttribute(Min=0, Max=(byte)7)] byte index);
++        public static Vector<short> DuplicateSelectedScalarToVector(Vector<short> data, [ConstantExpectedAttribute(Min=0, Max=(byte)31)] byte index);
++        public static Vector<int> DuplicateSelectedScalarToVector(Vector<int> data, [ConstantExpectedAttribute(Min=0, Max=(byte)15)] byte index);
++        public static Vector<long> DuplicateSelectedScalarToVector(Vector<long> data, [ConstantExpectedAttribute(Min=0, Max=(byte)7)] byte index);
++        public static Vector<sbyte> DuplicateSelectedScalarToVector(Vector<sbyte> data, [ConstantExpectedAttribute(Min=0, Max=(byte)63)] byte index);
++        public static Vector<float> DuplicateSelectedScalarToVector(Vector<float> data, [ConstantExpectedAttribute(Min=0, Max=(byte)15)] byte index);
++        public static Vector<ushort> DuplicateSelectedScalarToVector(Vector<ushort> data, [ConstantExpectedAttribute(Min=0, Max=(byte)31)] byte index);
++        public static Vector<uint> DuplicateSelectedScalarToVector(Vector<uint> data, [ConstantExpectedAttribute(Min=0, Max=(byte)15)] byte index);
++        public static Vector<ulong> DuplicateSelectedScalarToVector(Vector<ulong> data, [ConstantExpectedAttribute(Min=0, Max=(byte)7)] byte index);
++        public static Vector<byte> ExtractVector(Vector<byte> upper, Vector<byte> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<double> ExtractVector(Vector<double> upper, Vector<double> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<short> ExtractVector(Vector<short> upper, Vector<short> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<int> ExtractVector(Vector<int> upper, Vector<int> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<long> ExtractVector(Vector<long> upper, Vector<long> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<sbyte> ExtractVector(Vector<sbyte> upper, Vector<sbyte> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<float> ExtractVector(Vector<float> upper, Vector<float> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<ushort> ExtractVector(Vector<ushort> upper, Vector<ushort> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<uint> ExtractVector(Vector<uint> upper, Vector<uint> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<ulong> ExtractVector(Vector<ulong> upper, Vector<ulong> lower, [ConstantExpectedAttribute] byte index);
++        public static Vector<float> FloatingPointExponentialAccelerator(Vector<uint> value);
++        public static Vector<double> FloatingPointExponentialAccelerator(Vector<ulong> value);
++        public static void GatherPrefetch16Bit(Vector<short> mask, Vector<uint> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch16Bit(Vector<short> mask, Vector<ulong> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch16Bit(Vector<short> mask, void* address, Vector<int> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch16Bit(Vector<short> mask, void* address, Vector<long> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch16Bit(Vector<short> mask, void* address, Vector<uint> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch16Bit(Vector<short> mask, void* address, Vector<ulong> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch16Bit(Vector<ushort> mask, Vector<uint> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch16Bit(Vector<ushort> mask, Vector<ulong> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch16Bit(Vector<ushort> mask, void* address, Vector<int> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch16Bit(Vector<ushort> mask, void* address, Vector<long> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch16Bit(Vector<ushort> mask, void* address, Vector<uint> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch16Bit(Vector<ushort> mask, void* address, Vector<ulong> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch32Bit(Vector<int> mask, Vector<uint> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch32Bit(Vector<int> mask, Vector<ulong> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch32Bit(Vector<int> mask, void* address, Vector<int> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch32Bit(Vector<int> mask, void* address, Vector<long> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch32Bit(Vector<int> mask, void* address, Vector<uint> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch32Bit(Vector<int> mask, void* address, Vector<ulong> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch32Bit(Vector<uint> mask, Vector<uint> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch32Bit(Vector<uint> mask, Vector<ulong> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch32Bit(Vector<uint> mask, void* address, Vector<int> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch32Bit(Vector<uint> mask, void* address, Vector<long> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch32Bit(Vector<uint> mask, void* address, Vector<uint> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch32Bit(Vector<uint> mask, void* address, Vector<ulong> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch64Bit(Vector<long> mask, Vector<uint> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch64Bit(Vector<long> mask, Vector<ulong> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch64Bit(Vector<long> mask, void* address, Vector<int> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch64Bit(Vector<long> mask, void* address, Vector<long> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch64Bit(Vector<long> mask, void* address, Vector<uint> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch64Bit(Vector<long> mask, void* address, Vector<ulong> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch64Bit(Vector<ulong> mask, Vector<uint> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch64Bit(Vector<ulong> mask, Vector<ulong> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch64Bit(Vector<ulong> mask, void* address, Vector<int> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch64Bit(Vector<ulong> mask, void* address, Vector<long> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch64Bit(Vector<ulong> mask, void* address, Vector<uint> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch64Bit(Vector<ulong> mask, void* address, Vector<ulong> indices, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch8Bit(Vector<byte> mask, Vector<uint> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch8Bit(Vector<byte> mask, Vector<ulong> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch8Bit(Vector<byte> mask, void* address, Vector<int> offsets, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch8Bit(Vector<byte> mask, void* address, Vector<long> offsets, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch8Bit(Vector<byte> mask, void* address, Vector<uint> offsets, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch8Bit(Vector<byte> mask, void* address, Vector<ulong> offsets, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch8Bit(Vector<sbyte> mask, Vector<uint> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static void GatherPrefetch8Bit(Vector<sbyte> mask, Vector<ulong> addresses, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch8Bit(Vector<sbyte> mask, void* address, Vector<int> offsets, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch8Bit(Vector<sbyte> mask, void* address, Vector<long> offsets, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch8Bit(Vector<sbyte> mask, void* address, Vector<uint> offsets, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public unsafe static void GatherPrefetch8Bit(Vector<sbyte> mask, void* address, Vector<ulong> offsets, [ConstantExpectedAttribute] SvePrefetchType prefetchType);
++        public static Vector<byte> InsertIntoShiftedVector(Vector<byte> left, byte right);
++        public static Vector<double> InsertIntoShiftedVector(Vector<double> left, double right);
++        public static Vector<short> InsertIntoShiftedVector(Vector<short> left, short right);
++        public static Vector<int> InsertIntoShiftedVector(Vector<int> left, int right);
++        public static Vector<long> InsertIntoShiftedVector(Vector<long> left, long right);
++        public static Vector<sbyte> InsertIntoShiftedVector(Vector<sbyte> left, sbyte right);
++        public static Vector<float> InsertIntoShiftedVector(Vector<float> left, float right);
++        public static Vector<ushort> InsertIntoShiftedVector(Vector<ushort> left, ushort right);
++        public static Vector<uint> InsertIntoShiftedVector(Vector<uint> left, uint right);
++        public static Vector<ulong> InsertIntoShiftedVector(Vector<ulong> left, ulong right);
++        public static Vector<double> MultiplyAddRotateComplex(Vector<double> addend, Vector<double> left, Vector<double> right, [ConstantExpectedAttribute(Min=0, Max=(byte)3)] byte rotation);
++        public static Vector<float> MultiplyAddRotateComplex(Vector<float> addend, Vector<float> left, Vector<float> right, [ConstantExpectedAttribute(Min=0, Max=(byte)3)] byte rotation);
++        public static Vector<float> MultiplyAddRotateComplexBySelectedScalar(Vector<float> addend, Vector<float> left, Vector<float> right, [ConstantExpectedAttribute(Min=0, Max=(byte)1)] byte rightIndex, [ConstantExpectedAttribute(Min=0, Max=(byte)3)] byte rotation);
++        public static Vector<byte> Not(Vector<byte> value);
++        public static Vector<short> Not(Vector<short> value);
++        public static Vector<int> Not(Vector<int> value);
++        public static Vector<long> Not(Vector<long> value);
++        public static Vector<sbyte> Not(Vector<sbyte> value);
++        public static Vector<ushort> Not(Vector<ushort> value);
++        public static Vector<uint> Not(Vector<uint> value);
++        public static Vector<ulong> Not(Vector<ulong> value);
++        public static Vector<double> ReciprocalEstimate(Vector<double> value);
++        public static Vector<float> ReciprocalEstimate(Vector<float> value);
++        public static Vector<double> ReciprocalExponent(Vector<double> value);
++        public static Vector<float> ReciprocalExponent(Vector<float> value);
++        public static Vector<double> ReciprocalSqrtEstimate(Vector<double> value);
++        public static Vector<float> ReciprocalSqrtEstimate(Vector<float> value);
++        public static Vector<double> ReciprocalSqrtStep(Vector<double> left, Vector<double> right);
++        public static Vector<float> ReciprocalSqrtStep(Vector<float> left, Vector<float> right);
++        public static Vector<double> ReciprocalStep(Vector<double> left, Vector<double> right);
++        public static Vector<float> ReciprocalStep(Vector<float> left, Vector<float> right);
++        public static Vector<byte> ReverseBits(Vector<byte> value);
++        public static Vector<short> ReverseBits(Vector<short> value);
++        public static Vector<int> ReverseBits(Vector<int> value);
++        public static Vector<long> ReverseBits(Vector<long> value);
++        public static Vector<sbyte> ReverseBits(Vector<sbyte> value);
++        public static Vector<ushort> ReverseBits(Vector<ushort> value);
++        public static Vector<uint> ReverseBits(Vector<uint> value);
++        public static Vector<ulong> ReverseBits(Vector<ulong> value);
++        public static Vector<double> Scale(Vector<double> left, Vector<long> right);
++        public static Vector<float> Scale(Vector<float> left, Vector<int> right);
++        public unsafe static void Scatter(Vector<double> mask, double* address, Vector<long> indicies, Vector<double> data);
++        public unsafe static void Scatter(Vector<double> mask, double* address, Vector<ulong> indicies, Vector<double> data);
++        public static void Scatter(Vector<double> mask, Vector<ulong> addresses, Vector<double> data);
++        public unsafe static void Scatter(Vector<int> mask, int* address, Vector<int> indicies, Vector<int> data);
++        public unsafe static void Scatter(Vector<int> mask, int* address, Vector<uint> indicies, Vector<int> data);
++        public unsafe static void Scatter(Vector<long> mask, long* address, Vector<long> indicies, Vector<long> data);
++        public unsafe static void Scatter(Vector<long> mask, long* address, Vector<ulong> indicies, Vector<long> data);
++        public static void Scatter(Vector<long> mask, Vector<ulong> addresses, Vector<long> data);
++        public unsafe static void Scatter(Vector<float> mask, float* address, Vector<int> indicies, Vector<float> data);
++        public unsafe static void Scatter(Vector<float> mask, float* address, Vector<uint> indicies, Vector<float> data);
++        public unsafe static void Scatter(Vector<uint> mask, uint* address, Vector<int> indicies, Vector<uint> data);
++        public unsafe static void Scatter(Vector<uint> mask, uint* address, Vector<uint> indicies, Vector<uint> data);
++        public static void Scatter(Vector<ulong> mask, Vector<ulong> addresses, Vector<ulong> data);
++        public unsafe static void Scatter(Vector<ulong> mask, ulong* address, Vector<long> indicies, Vector<ulong> data);
++        public unsafe static void Scatter(Vector<ulong> mask, ulong* address, Vector<ulong> indicies, Vector<ulong> data);
++        public static void Scatter16BitNarrowing(Vector<long> mask, Vector<ulong> addresses, Vector<long> data);
++        public static void Scatter16BitNarrowing(Vector<ulong> mask, Vector<ulong> addresses, Vector<ulong> data);
++        public unsafe static void Scatter16BitWithByteOffsetsNarrowing(Vector<int> mask, short* address, Vector<int> offsets, Vector<int> data);
++        public unsafe static void Scatter16BitWithByteOffsetsNarrowing(Vector<int> mask, short* address, Vector<uint> offsets, Vector<int> data);
++        public unsafe static void Scatter16BitWithByteOffsetsNarrowing(Vector<long> mask, short* address, Vector<long> offsets, Vector<long> data);
++        public unsafe static void Scatter16BitWithByteOffsetsNarrowing(Vector<long> mask, short* address, Vector<ulong> offsets, Vector<long> data);
++        public unsafe static void Scatter16BitWithByteOffsetsNarrowing(Vector<uint> mask, ushort* address, Vector<int> offsets, Vector<uint> data);
++        public unsafe static void Scatter16BitWithByteOffsetsNarrowing(Vector<uint> mask, ushort* address, Vector<uint> offsets, Vector<uint> data);
++        public unsafe static void Scatter16BitWithByteOffsetsNarrowing(Vector<ulong> mask, ushort* address, Vector<long> offsets, Vector<ulong> data);
++        public unsafe static void Scatter16BitWithByteOffsetsNarrowing(Vector<ulong> mask, ushort* address, Vector<ulong> offsets, Vector<ulong> data);
++        public static void Scatter32BitNarrowing(Vector<long> mask, Vector<ulong> addresses, Vector<long> data);
++        public static void Scatter32BitNarrowing(Vector<ulong> mask, Vector<ulong> addresses, Vector<ulong> data);
++        public unsafe static void Scatter32BitWithByteOffsetsNarrowing(Vector<long> mask, int* address, Vector<long> offsets, Vector<long> data);
++        public unsafe static void Scatter32BitWithByteOffsetsNarrowing(Vector<long> mask, int* address, Vector<ulong> offsets, Vector<long> data);
++        public unsafe static void Scatter32BitWithByteOffsetsNarrowing(Vector<ulong> mask, uint* address, Vector<long> offsets, Vector<ulong> data);
++        public unsafe static void Scatter32BitWithByteOffsetsNarrowing(Vector<ulong> mask, uint* address, Vector<ulong> offsets, Vector<ulong> data);
++        public static void Scatter8BitNarrowing(Vector<long> mask, Vector<ulong> addresses, Vector<long> data);
++        public static void Scatter8BitNarrowing(Vector<ulong> mask, Vector<ulong> addresses, Vector<ulong> data);
++        public unsafe static void Scatter8BitWithByteOffsetsNarrowing(Vector<int> mask, sbyte* address, Vector<int> offsets, Vector<int> data);
++        public unsafe static void Scatter8BitWithByteOffsetsNarrowing(Vector<int> mask, sbyte* address, Vector<uint> offsets, Vector<int> data);
++        public unsafe static void Scatter8BitWithByteOffsetsNarrowing(Vector<long> mask, sbyte* address, Vector<long> offsets, Vector<long> data);
++        public unsafe static void Scatter8BitWithByteOffsetsNarrowing(Vector<long> mask, sbyte* address, Vector<ulong> offsets, Vector<long> data);
++        public unsafe static void Scatter8BitWithByteOffsetsNarrowing(Vector<uint> mask, byte* address, Vector<int> offsets, Vector<uint> data);
++        public unsafe static void Scatter8BitWithByteOffsetsNarrowing(Vector<uint> mask, byte* address, Vector<uint> offsets, Vector<uint> data);
++        public unsafe static void Scatter8BitWithByteOffsetsNarrowing(Vector<ulong> mask, byte* address, Vector<long> offsets, Vector<ulong> data);
++        public unsafe static void Scatter8BitWithByteOffsetsNarrowing(Vector<ulong> mask, byte* address, Vector<ulong> offsets, Vector<ulong> data);
++        public static Vector<byte> ShiftLeftLogical(Vector<byte> left, Vector<byte> right);
++        public static Vector<byte> ShiftLeftLogical(Vector<byte> left, Vector<ulong> right);
++        public static Vector<short> ShiftLeftLogical(Vector<short> left, Vector<ushort> right);
++        public static Vector<short> ShiftLeftLogical(Vector<short> left, Vector<ulong> right);
++        public static Vector<int> ShiftLeftLogical(Vector<int> left, Vector<uint> right);
++        public static Vector<int> ShiftLeftLogical(Vector<int> left, Vector<ulong> right);
++        public static Vector<long> ShiftLeftLogical(Vector<long> left, Vector<ulong> right);
++        public static Vector<sbyte> ShiftLeftLogical(Vector<sbyte> left, Vector<byte> right);
++        public static Vector<sbyte> ShiftLeftLogical(Vector<sbyte> left, Vector<ulong> right);
++        public static Vector<ushort> ShiftLeftLogical(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<ushort> ShiftLeftLogical(Vector<ushort> left, Vector<ulong> right);
++        public static Vector<uint> ShiftLeftLogical(Vector<uint> left, Vector<uint> right);
++        public static Vector<uint> ShiftLeftLogical(Vector<uint> left, Vector<ulong> right);
++        public static Vector<ulong> ShiftLeftLogical(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<short> ShiftRightArithmetic(Vector<short> left, Vector<ushort> right);
++        public static Vector<short> ShiftRightArithmetic(Vector<short> left, Vector<ulong> right);
++        public static Vector<int> ShiftRightArithmetic(Vector<int> left, Vector<uint> right);
++        public static Vector<int> ShiftRightArithmetic(Vector<int> left, Vector<ulong> right);
++        public static Vector<long> ShiftRightArithmetic(Vector<long> left, Vector<ulong> right);
++        public static Vector<sbyte> ShiftRightArithmetic(Vector<sbyte> left, Vector<byte> right);
++        public static Vector<sbyte> ShiftRightArithmetic(Vector<sbyte> left, Vector<ulong> right);
++        public static Vector<short> ShiftRightArithmeticForDivide(Vector<short> value, [ConstantExpectedAttribute(Min=1, Max=(byte)16)] byte control);
++        public static Vector<int> ShiftRightArithmeticForDivide(Vector<int> value, [ConstantExpectedAttribute(Min=1, Max=(byte)32)] byte control);
++        public static Vector<long> ShiftRightArithmeticForDivide(Vector<long> value, [ConstantExpectedAttribute(Min=1, Max=(byte)64)] byte control);
++        public static Vector<sbyte> ShiftRightArithmeticForDivide(Vector<sbyte> value, [ConstantExpectedAttribute(Min=1, Max=(byte)8)] byte control);
++        public static Vector<byte> ShiftRightLogical(Vector<byte> left, Vector<byte> right);
++        public static Vector<byte> ShiftRightLogical(Vector<byte> left, Vector<ulong> right);
++        public static Vector<ushort> ShiftRightLogical(Vector<ushort> left, Vector<ushort> right);
++        public static Vector<ushort> ShiftRightLogical(Vector<ushort> left, Vector<ulong> right);
++        public static Vector<uint> ShiftRightLogical(Vector<uint> left, Vector<uint> right);
++        public static Vector<uint> ShiftRightLogical(Vector<uint> left, Vector<ulong> right);
++        public static Vector<ulong> ShiftRightLogical(Vector<ulong> left, Vector<ulong> right);
++        public static Vector<byte> Splice(Vector<byte> mask, Vector<byte> left, Vector<byte> right);
++        public static Vector<double> Splice(Vector<double> mask, Vector<double> left, Vector<double> right);
++        public static Vector<short> Splice(Vector<short> mask, Vector<short> left, Vector<short> right);
++        public static Vector<int> Splice(Vector<int> mask, Vector<int> left, Vector<int> right);
++        public static Vector<long> Splice(Vector<long> mask, Vector<long> left, Vector<long> right);
++        public static Vector<sbyte> Splice(Vector<sbyte> mask, Vector<sbyte> left, Vector<sbyte> right);
++        public static Vector<float> Splice(Vector<float> mask, Vector<float> left, Vector<float> right);
++        public static Vector<ushort> Splice(Vector<ushort> mask, Vector<ushort> left, Vector<ushort> right);
++        public static Vector<uint> Splice(Vector<uint> mask, Vector<uint> left, Vector<uint> right);
++        public static Vector<ulong> Splice(Vector<ulong> mask, Vector<ulong> left, Vector<ulong> right);
++        public static Vector<double> Sqrt(Vector<double> value);
++        public static Vector<float> Sqrt(Vector<float> value);
++        public static bool TestAnyTrue(Vector<byte> mask, Vector<byte> srcMask);
++        public static bool TestAnyTrue(Vector<short> mask, Vector<short> srcMask);
++        public static bool TestAnyTrue(Vector<int> mask, Vector<int> srcMask);
++        public static bool TestAnyTrue(Vector<long> mask, Vector<long> srcMask);
++        public static bool TestAnyTrue(Vector<sbyte> mask, Vector<sbyte> srcMask);
++        public static bool TestAnyTrue(Vector<ushort> mask, Vector<ushort> srcMask);
++        public static bool TestAnyTrue(Vector<uint> mask, Vector<uint> srcMask);
++        public static bool TestAnyTrue(Vector<ulong> mask, Vector<ulong> srcMask);
++        public static bool TestFirstTrue(Vector<byte> mask, Vector<byte> srcMask);
++        public static bool TestFirstTrue(Vector<short> mask, Vector<short> srcMask);
++        public static bool TestFirstTrue(Vector<int> mask, Vector<int> srcMask);
++        public static bool TestFirstTrue(Vector<long> mask, Vector<long> srcMask);
++        public static bool TestFirstTrue(Vector<sbyte> mask, Vector<sbyte> srcMask);
++        public static bool TestFirstTrue(Vector<ushort> mask, Vector<ushort> srcMask);
++        public static bool TestFirstTrue(Vector<uint> mask, Vector<uint> srcMask);
++        public static bool TestFirstTrue(Vector<ulong> mask, Vector<ulong> srcMask);
++        public static bool TestLastTrue(Vector<byte> mask, Vector<byte> srcMask);
++        public static bool TestLastTrue(Vector<short> mask, Vector<short> srcMask);
++        public static bool TestLastTrue(Vector<int> mask, Vector<int> srcMask);
++        public static bool TestLastTrue(Vector<long> mask, Vector<long> srcMask);
++        public static bool TestLastTrue(Vector<sbyte> mask, Vector<sbyte> srcMask);
++        public static bool TestLastTrue(Vector<ushort> mask, Vector<ushort> srcMask);
++        public static bool TestLastTrue(Vector<uint> mask, Vector<uint> srcMask);
++        public static bool TestLastTrue(Vector<ulong> mask, Vector<ulong> srcMask);
++        public static Vector<double> TrigonometricMultiplyAddCoefficient(Vector<double> left, Vector<double> right, [ConstantExpectedAttribute(Min=0, Max=(byte)7)] byte control);
++        public static Vector<float> TrigonometricMultiplyAddCoefficient(Vector<float> left, Vector<float> right, [ConstantExpectedAttribute(Min=0, Max=(byte)7)] byte control);
++        public static Vector<double> TrigonometricSelectCoefficient(Vector<double> value, Vector<ulong> selector);
++        public static Vector<float> TrigonometricSelectCoefficient(Vector<float> value, Vector<uint> selector);
++        public static Vector<double> TrigonometricStartingValue(Vector<double> value, Vector<ulong> sign);
++        public static Vector<float> TrigonometricStartingValue(Vector<float> value, Vector<uint> sign);
++        public static Vector<byte> VectorTableLookup(Vector<byte> data, Vector<byte> indices);
++        public static Vector<double> VectorTableLookup(Vector<double> data, Vector<ulong> indices);
++        public static Vector<short> VectorTableLookup(Vector<short> data, Vector<ushort> indices);
++        public static Vector<int> VectorTableLookup(Vector<int> data, Vector<uint> indices);
++        public static Vector<long> VectorTableLookup(Vector<long> data, Vector<ulong> indices);
++        public static Vector<sbyte> VectorTableLookup(Vector<sbyte> data, Vector<byte> indices);
++        public static Vector<float> VectorTableLookup(Vector<float> data, Vector<uint> indices);
++        public static Vector<ushort> VectorTableLookup(Vector<ushort> data, Vector<ushort> indices);
++        public static Vector<uint> VectorTableLookup(Vector<uint> data, Vector<uint> indices);
++        public static Vector<ulong> VectorTableLookup(Vector<ulong> data, Vector<ulong> indices);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Runtime.Intrinsics.md

@@ -0,0 +1,159 @@
+# System.Runtime.Intrinsics
+
+``` diff
+ namespace System.Runtime.Intrinsics {
+     public static class Vector128 {
++        public static Vector128<T> Clamp<T>(Vector128<T> value, Vector128<T> min, Vector128<T> max);
++        public static Vector128<T> ClampNative<T>(Vector128<T> value, Vector128<T> min, Vector128<T> max);
++        public static Vector128<T> CopySign<T>(Vector128<T> value, Vector128<T> sign);
++        public static Vector128<double> Cos(Vector128<double> vector);
++        public static Vector128<float> Cos(Vector128<float> vector);
++        public static Vector128<double> DegreesToRadians(Vector128<double> degrees);
++        public static Vector128<float> DegreesToRadians(Vector128<float> degrees);
++        public static Vector128<double> Hypot(Vector128<double> x, Vector128<double> y);
++        public static Vector128<float> Hypot(Vector128<float> x, Vector128<float> y);
++        public static Vector128<T> IsNaN<T>(Vector128<T> vector);
++        public static Vector128<T> IsNegative<T>(Vector128<T> vector);
++        public static Vector128<T> IsPositive<T>(Vector128<T> vector);
++        public static Vector128<T> IsPositiveInfinity<T>(Vector128<T> vector);
++        public static Vector128<T> IsZero<T>(Vector128<T> vector);
++        public static Vector128<double> Lerp(Vector128<double> x, Vector128<double> y, Vector128<double> amount);
++        public static Vector128<float> Lerp(Vector128<float> x, Vector128<float> y, Vector128<float> amount);
++        public static Vector128<T> MaxMagnitude<T>(Vector128<T> left, Vector128<T> right);
++        public static Vector128<T> MaxMagnitudeNumber<T>(Vector128<T> left, Vector128<T> right);
++        public static Vector128<T> MaxNative<T>(Vector128<T> left, Vector128<T> right);
++        public static Vector128<T> MaxNumber<T>(Vector128<T> left, Vector128<T> right);
++        public static Vector128<T> MinMagnitude<T>(Vector128<T> left, Vector128<T> right);
++        public static Vector128<T> MinMagnitudeNumber<T>(Vector128<T> left, Vector128<T> right);
++        public static Vector128<T> MinNative<T>(Vector128<T> left, Vector128<T> right);
++        public static Vector128<T> MinNumber<T>(Vector128<T> left, Vector128<T> right);
++        public static Vector128<double> RadiansToDegrees(Vector128<double> radians);
++        public static Vector128<float> RadiansToDegrees(Vector128<float> radians);
++        public static Vector128<double> Round(Vector128<double> vector);
++        public static Vector128<double> Round(Vector128<double> vector, MidpointRounding mode);
++        public static Vector128<float> Round(Vector128<float> vector);
++        public static Vector128<float> Round(Vector128<float> vector, MidpointRounding mode);
++        public static Vector128<double> Sin(Vector128<double> vector);
++        public static Vector128<float> Sin(Vector128<float> vector);
++        public static (Vector128<double> Sin, Vector128<double> Cos) SinCos(Vector128<double> vector);
++        public static (Vector128<float> Sin, Vector128<float> Cos) SinCos(Vector128<float> vector);
++        public static Vector128<double> Truncate(Vector128<double> vector);
++        public static Vector128<float> Truncate(Vector128<float> vector);
+     }
+     public static class Vector256 {
++        public static Vector256<T> Clamp<T>(Vector256<T> value, Vector256<T> min, Vector256<T> max);
++        public static Vector256<T> ClampNative<T>(Vector256<T> value, Vector256<T> min, Vector256<T> max);
++        public static Vector256<T> CopySign<T>(Vector256<T> value, Vector256<T> sign);
++        public static Vector256<double> Cos(Vector256<double> vector);
++        public static Vector256<float> Cos(Vector256<float> vector);
++        public static Vector256<double> DegreesToRadians(Vector256<double> degrees);
++        public static Vector256<float> DegreesToRadians(Vector256<float> degrees);
++        public static Vector256<double> Hypot(Vector256<double> x, Vector256<double> y);
++        public static Vector256<float> Hypot(Vector256<float> x, Vector256<float> y);
++        public static Vector256<T> IsNaN<T>(Vector256<T> vector);
++        public static Vector256<T> IsNegative<T>(Vector256<T> vector);
++        public static Vector256<T> IsPositive<T>(Vector256<T> vector);
++        public static Vector256<T> IsPositiveInfinity<T>(Vector256<T> vector);
++        public static Vector256<T> IsZero<T>(Vector256<T> vector);
++        public static Vector256<double> Lerp(Vector256<double> x, Vector256<double> y, Vector256<double> amount);
++        public static Vector256<float> Lerp(Vector256<float> x, Vector256<float> y, Vector256<float> amount);
++        public static Vector256<T> MaxMagnitude<T>(Vector256<T> left, Vector256<T> right);
++        public static Vector256<T> MaxMagnitudeNumber<T>(Vector256<T> left, Vector256<T> right);
++        public static Vector256<T> MaxNative<T>(Vector256<T> left, Vector256<T> right);
++        public static Vector256<T> MaxNumber<T>(Vector256<T> left, Vector256<T> right);
++        public static Vector256<T> MinMagnitude<T>(Vector256<T> left, Vector256<T> right);
++        public static Vector256<T> MinMagnitudeNumber<T>(Vector256<T> left, Vector256<T> right);
++        public static Vector256<T> MinNative<T>(Vector256<T> left, Vector256<T> right);
++        public static Vector256<T> MinNumber<T>(Vector256<T> left, Vector256<T> right);
++        public static Vector256<double> RadiansToDegrees(Vector256<double> radians);
++        public static Vector256<float> RadiansToDegrees(Vector256<float> radians);
++        public static Vector256<double> Round(Vector256<double> vector);
++        public static Vector256<double> Round(Vector256<double> vector, MidpointRounding mode);
++        public static Vector256<float> Round(Vector256<float> vector);
++        public static Vector256<float> Round(Vector256<float> vector, MidpointRounding mode);
++        public static Vector256<double> Sin(Vector256<double> vector);
++        public static Vector256<float> Sin(Vector256<float> vector);
++        public static (Vector256<double> Sin, Vector256<double> Cos) SinCos(Vector256<double> vector);
++        public static (Vector256<float> Sin, Vector256<float> Cos) SinCos(Vector256<float> vector);
++        public static Vector256<double> Truncate(Vector256<double> vector);
++        public static Vector256<float> Truncate(Vector256<float> vector);
+     }
+     public static class Vector512 {
++        public static Vector512<T> Clamp<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max);
++        public static Vector512<T> ClampNative<T>(Vector512<T> value, Vector512<T> min, Vector512<T> max);
++        public static Vector512<T> CopySign<T>(Vector512<T> value, Vector512<T> sign);
++        public static Vector512<double> Cos(Vector512<double> vector);
++        public static Vector512<float> Cos(Vector512<float> vector);
++        public static Vector512<double> DegreesToRadians(Vector512<double> degrees);
++        public static Vector512<float> DegreesToRadians(Vector512<float> degrees);
++        public static Vector512<double> Hypot(Vector512<double> x, Vector512<double> y);
++        public static Vector512<float> Hypot(Vector512<float> x, Vector512<float> y);
++        public static Vector512<T> IsNaN<T>(Vector512<T> vector);
++        public static Vector512<T> IsNegative<T>(Vector512<T> vector);
++        public static Vector512<T> IsPositive<T>(Vector512<T> vector);
++        public static Vector512<T> IsPositiveInfinity<T>(Vector512<T> vector);
++        public static Vector512<T> IsZero<T>(Vector512<T> vector);
++        public static Vector512<double> Lerp(Vector512<double> x, Vector512<double> y, Vector512<double> amount);
++        public static Vector512<float> Lerp(Vector512<float> x, Vector512<float> y, Vector512<float> amount);
++        public static Vector512<T> MaxMagnitude<T>(Vector512<T> left, Vector512<T> right);
++        public static Vector512<T> MaxMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right);
++        public static Vector512<T> MaxNative<T>(Vector512<T> left, Vector512<T> right);
++        public static Vector512<T> MaxNumber<T>(Vector512<T> left, Vector512<T> right);
++        public static Vector512<T> MinMagnitude<T>(Vector512<T> left, Vector512<T> right);
++        public static Vector512<T> MinMagnitudeNumber<T>(Vector512<T> left, Vector512<T> right);
++        public static Vector512<T> MinNative<T>(Vector512<T> left, Vector512<T> right);
++        public static Vector512<T> MinNumber<T>(Vector512<T> left, Vector512<T> right);
++        public static Vector512<double> RadiansToDegrees(Vector512<double> radians);
++        public static Vector512<float> RadiansToDegrees(Vector512<float> radians);
++        public static Vector512<double> Round(Vector512<double> vector);
++        public static Vector512<double> Round(Vector512<double> vector, MidpointRounding mode);
++        public static Vector512<float> Round(Vector512<float> vector);
++        public static Vector512<float> Round(Vector512<float> vector, MidpointRounding mode);
++        public static Vector512<double> Sin(Vector512<double> vector);
++        public static Vector512<float> Sin(Vector512<float> vector);
++        public static (Vector512<double> Sin, Vector512<double> Cos) SinCos(Vector512<double> vector);
++        public static (Vector512<float> Sin, Vector512<float> Cos) SinCos(Vector512<float> vector);
++        public static Vector512<double> Truncate(Vector512<double> vector);
++        public static Vector512<float> Truncate(Vector512<float> vector);
+     }
+     public static class Vector64 {
++        public static Vector64<T> Clamp<T>(Vector64<T> value, Vector64<T> min, Vector64<T> max);
++        public static Vector64<T> ClampNative<T>(Vector64<T> value, Vector64<T> min, Vector64<T> max);
++        public static Vector64<T> CopySign<T>(Vector64<T> value, Vector64<T> sign);
++        public static Vector64<double> Cos(Vector64<double> vector);
++        public static Vector64<float> Cos(Vector64<float> vector);
++        public static Vector64<double> DegreesToRadians(Vector64<double> degrees);
++        public static Vector64<float> DegreesToRadians(Vector64<float> degrees);
++        public static Vector64<double> Hypot(Vector64<double> x, Vector64<double> y);
++        public static Vector64<float> Hypot(Vector64<float> x, Vector64<float> y);
++        public static Vector64<T> IsNaN<T>(Vector64<T> vector);
++        public static Vector64<T> IsNegative<T>(Vector64<T> vector);
++        public static Vector64<T> IsPositive<T>(Vector64<T> vector);
++        public static Vector64<T> IsPositiveInfinity<T>(Vector64<T> vector);
++        public static Vector64<T> IsZero<T>(Vector64<T> vector);
++        public static Vector64<double> Lerp(Vector64<double> x, Vector64<double> y, Vector64<double> amount);
++        public static Vector64<float> Lerp(Vector64<float> x, Vector64<float> y, Vector64<float> amount);
++        public static Vector64<T> MaxMagnitude<T>(Vector64<T> left, Vector64<T> right);
++        public static Vector64<T> MaxMagnitudeNumber<T>(Vector64<T> left, Vector64<T> right);
++        public static Vector64<T> MaxNative<T>(Vector64<T> left, Vector64<T> right);
++        public static Vector64<T> MaxNumber<T>(Vector64<T> left, Vector64<T> right);
++        public static Vector64<T> MinMagnitude<T>(Vector64<T> left, Vector64<T> right);
++        public static Vector64<T> MinMagnitudeNumber<T>(Vector64<T> left, Vector64<T> right);
++        public static Vector64<T> MinNative<T>(Vector64<T> left, Vector64<T> right);
++        public static Vector64<T> MinNumber<T>(Vector64<T> left, Vector64<T> right);
++        public static Vector64<double> RadiansToDegrees(Vector64<double> radians);
++        public static Vector64<float> RadiansToDegrees(Vector64<float> radians);
++        public static Vector64<double> Round(Vector64<double> vector);
++        public static Vector64<double> Round(Vector64<double> vector, MidpointRounding mode);
++        public static Vector64<float> Round(Vector64<float> vector);
++        public static Vector64<float> Round(Vector64<float> vector, MidpointRounding mode);
++        public static Vector64<double> Sin(Vector64<double> vector);
++        public static Vector64<float> Sin(Vector64<float> vector);
++        public static (Vector64<double> Sin, Vector64<double> Cos) SinCos(Vector64<double> vector);
++        public static (Vector64<float> Sin, Vector64<float> Cos) SinCos(Vector64<float> vector);
++        public static Vector64<double> Truncate(Vector64<double> vector);
++        public static Vector64<float> Truncate(Vector64<float> vector);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Security.Cryptography.X509Certificates.md

@@ -0,0 +1,282 @@
+# System.Security.Cryptography.X509Certificates
+
+``` diff
+ namespace System.Security.Cryptography.X509Certificates {
++    public sealed class Pkcs12LoaderLimits {
++        public Pkcs12LoaderLimits();
++        public Pkcs12LoaderLimits(Pkcs12LoaderLimits copyFrom);
++        public static Pkcs12LoaderLimits DangerousNoLimits { get; }
++        public static Pkcs12LoaderLimits Defaults { get; }
++        public bool IgnoreEncryptedAuthSafes { get; set; }
++        public bool IgnorePrivateKeys { get; set; }
++        public int? IndividualKdfIterationLimit { get; set; }
++        public bool IsReadOnly { get; }
++        public int? MacIterationLimit { get; set; }
++        public int? MaxCertificates { get; set; }
++        public int? MaxKeys { get; set; }
++        public bool PreserveCertificateAlias { get; set; }
++        public bool PreserveKeyName { get; set; }
++        public bool PreserveStorageProvider { get; set; }
++        public bool PreserveUnknownAttributes { get; set; }
++        public int? TotalKdfIterationLimit { get; set; }
++        public void MakeReadOnly();
++    }
++    public sealed class Pkcs12LoadLimitExceededException : CryptographicException {
++        public Pkcs12LoadLimitExceededException(string propertyName);
++    }
+     public class X509Certificate : IDeserializationCallback, IDisposable, ISerializable {
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate();
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate();
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(byte[] data);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(byte[] data);
+-        [CLSCompliantAttribute(false)]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(byte[] rawData, SecureString? password);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(byte[] rawData, SecureString? password);
+-        [CLSCompliantAttribute(false)]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(byte[] rawData, string? password);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(byte[] rawData, string? password);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(string fileName);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(string fileName);
+-        [CLSCompliantAttribute(false)]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(string fileName, SecureString? password);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(string fileName, SecureString? password);
+-        [CLSCompliantAttribute(false)]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(string fileName, string? password);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(string fileName, string? password);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate(string fileName, string? password, X509KeyStorageFlags keyStorageFlags);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate(string fileName, string? password, X509KeyStorageFlags keyStorageFlags);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public static X509Certificate CreateFromCertFile(string filename);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public static X509Certificate CreateFromCertFile(string filename);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public static X509Certificate CreateFromSignedFile(string filename);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public static X509Certificate CreateFromSignedFile(string filename);
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public virtual void Import(byte[] rawData);
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public virtual void Import(byte[] rawData);
+-        [CLSCompliantAttribute(false)]
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public virtual void Import(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public virtual void Import(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags);
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public virtual void Import(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags);
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public virtual void Import(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags);
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public virtual void Import(string fileName);
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public virtual void Import(string fileName);
+-        [CLSCompliantAttribute(false)]
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public virtual void Import(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public virtual void Import(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags);
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public virtual void Import(string fileName, string? password, X509KeyStorageFlags keyStorageFlags);
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public virtual void Import(string fileName, string? password, X509KeyStorageFlags keyStorageFlags);
+     }
+     public class X509Certificate2 : X509Certificate {
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2();
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2();
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(byte[] rawData);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(byte[] rawData);
+-        [CLSCompliantAttribute(false)]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(byte[] rawData, SecureString? password);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(byte[] rawData, SecureString? password);
+-        [CLSCompliantAttribute(false)]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(byte[] rawData, string? password);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(byte[] rawData, string? password);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(ReadOnlySpan<byte> rawData);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(ReadOnlySpan<byte> rawData);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(ReadOnlySpan<byte> rawData, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(ReadOnlySpan<byte> rawData, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(string fileName);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(string fileName);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(string fileName, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(string fileName, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
+-        [CLSCompliantAttribute(false)]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(string fileName, SecureString? password);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(string fileName, SecureString? password);
+-        [CLSCompliantAttribute(false)]
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(string fileName, string? password);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(string fileName, string? password);
+-        [UnsupportedOSPlatformAttribute("browser")]
+-        public X509Certificate2(string fileName, string? password, X509KeyStorageFlags keyStorageFlags);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        public X509Certificate2(string fileName, string? password, X509KeyStorageFlags keyStorageFlags);
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public override void Import(byte[] rawData);
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public override void Import(byte[] rawData);
+-        [CLSCompliantAttribute(false)]
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public override void Import(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public override void Import(byte[] rawData, SecureString? password, X509KeyStorageFlags keyStorageFlags);
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public override void Import(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags);
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public override void Import(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags);
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public override void Import(string fileName);
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public override void Import(string fileName);
+-        [CLSCompliantAttribute(false)]
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public override void Import(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags);
++        [CLSCompliantAttribute(false)]
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public override void Import(string fileName, SecureString? password, X509KeyStorageFlags keyStorageFlags);
+-        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
+-        public override void Import(string fileName, string? password, X509KeyStorageFlags keyStorageFlags);
++        [ObsoleteAttribute("X509Certificate and X509Certificate2 are immutable. Use X509CertificateLoader to create a new certificate.", DiagnosticId="SYSLIB0026", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public override void Import(string fileName, string? password, X509KeyStorageFlags keyStorageFlags);
+     }
+     public class X509Certificate2Collection : X509CertificateCollection, IEnumerable, IEnumerable<X509Certificate2> {
+-        public void Import(byte[] rawData);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public void Import(byte[] rawData);
+-        public void Import(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public void Import(byte[] rawData, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
+-        public void Import(ReadOnlySpan<byte> rawData);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public void Import(ReadOnlySpan<byte> rawData);
+-        public void Import(ReadOnlySpan<byte> rawData, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public void Import(ReadOnlySpan<byte> rawData, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
+-        public void Import(ReadOnlySpan<byte> rawData, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public void Import(ReadOnlySpan<byte> rawData, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
+-        public void Import(string fileName);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public void Import(string fileName);
+-        public void Import(string fileName, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public void Import(string fileName, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
+-        public void Import(string fileName, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
++        [ObsoleteAttribute("Loading certificate data through the constructor or Import is obsolete. Use X509CertificateLoader instead to load certificates.", DiagnosticId="SYSLIB0057", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
++        public void Import(string fileName, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet);
+     }
++    [UnsupportedOSPlatformAttribute("browser")]
++    public static class X509CertificateLoader {
++        public static X509Certificate2 LoadCertificate(byte[] data);
++        public static X509Certificate2 LoadCertificate(ReadOnlySpan<byte> data);
++        public static X509Certificate2 LoadCertificateFromFile(string path);
++        public static X509Certificate2 LoadPkcs12(byte[] data, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet, Pkcs12LoaderLimits? loaderLimits = null);
++        public static X509Certificate2 LoadPkcs12(ReadOnlySpan<byte> data, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet, Pkcs12LoaderLimits? loaderLimits = null);
++        public static X509Certificate2Collection LoadPkcs12Collection(byte[] data, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet, Pkcs12LoaderLimits? loaderLimits = null);
++        public static X509Certificate2Collection LoadPkcs12Collection(ReadOnlySpan<byte> data, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet, Pkcs12LoaderLimits? loaderLimits = null);
++        public static X509Certificate2Collection LoadPkcs12CollectionFromFile(string path, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet, Pkcs12LoaderLimits? loaderLimits = null);
++        public static X509Certificate2Collection LoadPkcs12CollectionFromFile(string path, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet, Pkcs12LoaderLimits? loaderLimits = null);
++        public static X509Certificate2 LoadPkcs12FromFile(string path, ReadOnlySpan<char> password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet, Pkcs12LoaderLimits? loaderLimits = null);
++        public static X509Certificate2 LoadPkcs12FromFile(string path, string? password, X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet, Pkcs12LoaderLimits? loaderLimits = null);
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Security.Cryptography.md

@@ -0,0 +1,35 @@
+# System.Security.Cryptography
+
+``` diff
+ namespace System.Security.Cryptography {
++    [SupportedOSPlatformAttribute("ios13.0")]
++    [SupportedOSPlatformAttribute("maccatalyst")]
++    [SupportedOSPlatformAttribute("tvos13.0")]
+     [UnsupportedOSPlatformAttribute("browser")]
+     [UnsupportedOSPlatformAttribute("ios")]
+     [UnsupportedOSPlatformAttribute("tvos")]
+     public sealed class AesGcm : IDisposable
++    [SupportedOSPlatformAttribute("ios13.0")]
++    [SupportedOSPlatformAttribute("maccatalyst")]
++    [SupportedOSPlatformAttribute("tvos13.0")]
+     [UnsupportedOSPlatformAttribute("browser")]
+     [UnsupportedOSPlatformAttribute("ios")]
+     [UnsupportedOSPlatformAttribute("tvos")]
+     public sealed class ChaCha20Poly1305 : IDisposable
+     [FlagsAttribute]
+     public enum CngKeyCreationOptions {
++        PreferVbs = 65536,
++        RequireVbs = 131072,
++        UsePerBootKey = 262144,
+     }
+     public sealed class SafeEvpPKeyHandle : SafeHandle {
++        [UnsupportedOSPlatformAttribute("android")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        [UnsupportedOSPlatformAttribute("ios")]
++        [UnsupportedOSPlatformAttribute("tvos")]
++        [UnsupportedOSPlatformAttribute("windows")]
++        public static SafeEvpPKeyHandle OpenKeyFromProvider(string providerName, string keyUri);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Text.Json.Schema.md

@@ -0,0 +1,12 @@
+# System.Text.Json.Schema
+
+``` diff
+ namespace System.Text.Json.Schema {
+     public readonly struct JsonSchemaExporterContext {
++        public JsonTypeInfo BaseTypeInfo { get; }
+-        public JsonPropertyInfo? PropertyInfo { get; }
++        public JsonPropertyInfo PropertyInfo { get; }
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Text.Json.Serialization.md

@@ -0,0 +1,12 @@
+# System.Text.Json.Serialization
+
+``` diff
+ namespace System.Text.Json.Serialization {
++    [AttributeUsageAttribute(AttributeTargets.Field, AllowMultiple=false)]
++    public class JsonStringEnumMemberNameAttribute : Attribute {
++        public JsonStringEnumMemberNameAttribute(string name);
++        public string Name { get; }
++    }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Text.Json.md

@@ -0,0 +1,18 @@
+# System.Text.Json
+
+``` diff
+ namespace System.Text.Json {
+     public readonly struct JsonElement {
++        public static bool DeepEquals(JsonElement element1, JsonElement element2);
+     }
+     public struct JsonReaderOptions {
++        public bool AllowMultipleValues { get; set; }
+     }
+     public static class JsonSerializer {
++        [RequiresUnreferencedCodeAttribute("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")]
++        public static IAsyncEnumerable<TValue?> DeserializeAsyncEnumerable<TValue>(Stream utf8Json, bool topLevelValues, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken));
++        public static IAsyncEnumerable<TValue?> DeserializeAsyncEnumerable<TValue>(Stream utf8Json, JsonTypeInfo<TValue> jsonTypeInfo, bool topLevelValues, CancellationToken cancellationToken = default(CancellationToken));
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.Threading.md

@@ -0,0 +1,17 @@
+# System.Threading
+
+``` diff
+ namespace System.Threading {
+     public static class Interlocked {
+-        [return: NotNullIfNotNullAttribute("location1")]
+-        public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class?;
++        [return: NotNullIfNotNullAttribute("location1")]
++        public static T CompareExchange<T>(ref T location1, T value, T comparand);
+-        [return: NotNullIfNotNullAttribute("location1")]
+-        public static T Exchange<T>([NotNullIfNotNullAttribute("value")] ref T location1, T value) where T : class?;
++        [return: NotNullIfNotNullAttribute("location1")]
++        public static T Exchange<T>([NotNullIfNotNullAttribute("value")] ref T location1, T value);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.NETCore.App/9.0-preview7_System.md

@@ -0,0 +1,54 @@
+# System
+
+``` diff
+ namespace System {
+     public static class Environment {
++        [SupportedOSPlatformAttribute("maccatalyst")]
++        [UnsupportedOSPlatformAttribute("browser")]
++        [UnsupportedOSPlatformAttribute("ios")]
++        [UnsupportedOSPlatformAttribute("tvos")]
++        public static Environment.ProcessCpuUsage CpuUsage { get; }
++        public readonly struct ProcessCpuUsage {
++            public TimeSpan PrivilegedTime { get; }
++            public TimeSpan TotalTime { get; }
++            public TimeSpan UserTime { get; }
++        }
+     }
+     public readonly struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable, IParsable<Guid>, ISpanFormattable, ISpanParsable<Guid>, IUtf8SpanFormattable {
++        public static Guid AllBitsSet { get; }
++        public int Variant { get; }
++        public int Version { get; }
++        public static Guid CreateVersion7();
++        public static Guid CreateVersion7(DateTimeOffset timestamp);
+     }
+     public static class MemoryExtensions {
++        public static MemoryExtensions.SpanSplitEnumerator<T> Split<T>(this ReadOnlySpan<T> source, ReadOnlySpan<T> separator) where T : IEquatable<T>;
++        public static MemoryExtensions.SpanSplitEnumerator<T> Split<T>(this ReadOnlySpan<T> source, T separator) where T : IEquatable<T>;
++        public static MemoryExtensions.SpanSplitEnumerator<T> SplitAny<T>(this ReadOnlySpan<T> source, SearchValues<T> separators) where T : IEquatable<T>;
++        public static MemoryExtensions.SpanSplitEnumerator<T> SplitAny<T>(this ReadOnlySpan<T> source, [ParamCollectionAttribute, UnscopedRefAttribute] ReadOnlySpan<T> separators) where T : IEquatable<T>;
++        public ref struct SpanSplitEnumerator<T> where T : IEquatable<T> {
++            public Range Current { get; }
++            public MemoryExtensions.SpanSplitEnumerator<T> GetEnumerator();
++            public bool MoveNext();
++        }
+     }
+     public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable, IParsable<TimeSpan>, ISpanFormattable, ISpanParsable<TimeSpan>, IUtf8SpanFormattable {
++        public const int HoursPerDay = 24;
++        public const long MicrosecondsPerDay = (long)86400000000;
++        public const long MicrosecondsPerHour = (long)3600000000;
++        public const long MicrosecondsPerMillisecond = (long)1000;
++        public const long MicrosecondsPerMinute = (long)60000000;
++        public const long MicrosecondsPerSecond = (long)1000000;
++        public const long MillisecondsPerDay = (long)86400000;
++        public const long MillisecondsPerHour = (long)3600000;
++        public const long MillisecondsPerMinute = (long)60000;
++        public const long MillisecondsPerSecond = (long)1000;
++        public const long MinutesPerDay = (long)1440;
++        public const long MinutesPerHour = (long)60;
++        public const long SecondsPerDay = (long)86400;
++        public const long SecondsPerHour = (long)3600;
++        public const long SecondsPerMinute = (long)60;
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.WindowsDesktop.App/9.0-preview7.md

@@ -0,0 +1,10 @@
+# API Difference 9.0-preview6 vs 9.0-preview7
+
+API listing follows standard diff formatting.
+Lines preceded by a '+' are additions and a '-' indicates removal.
+
+* [System.Drawing.Drawing2D](9.0-preview7_System.Drawing.Drawing2D.md)
+* [System.Formats.Nrbf](9.0-preview7_System.Formats.Nrbf.md)
+* [System.Windows](9.0-preview7_System.Windows.md)
+* [System.Windows.Forms](9.0-preview7_System.Windows.Forms.md)
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.WindowsDesktop.App/9.0-preview7_System.Drawing.Drawing2D.md

@@ -0,0 +1,11 @@
+# System.Drawing.Drawing2D
+
+``` diff
+ namespace System.Drawing.Drawing2D {
+     public sealed class GraphicsPathIterator : MarshalByRefObject, IDisposable {
++        public int CopyData(Span<PointF> points, Span<byte> types, int startIndex, int endIndex);
++        public int Enumerate(Span<PointF> points, Span<byte> types);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.WindowsDesktop.App/9.0-preview7_System.Formats.Nrbf.md

@@ -0,0 +1,11 @@
+# System.Formats.Nrbf
+
+``` diff
+ namespace System.Formats.Nrbf {
+     public static class NrbfDecoder {
+-        public static bool StartsWithPayloadHeader(byte[] bytes);
++        public static bool StartsWithPayloadHeader(ReadOnlySpan<byte> bytes);
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.WindowsDesktop.App/9.0-preview7_System.Windows.Forms.md

@@ -0,0 +1,29 @@
+# System.Windows.Forms
+
+``` diff
+ namespace System.Windows.Forms {
+     [DefaultEventAttribute("ItemClicked")]
+     [DefaultPropertyAttribute("Items")]
+     [DesignerAttribute("System.Windows.Forms.Design.ToolStripDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+     [DesignerSerializerAttribute("System.Windows.Forms.Design.ToolStripCodeDomSerializer, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.ComponentModel.Design.Serialization.CodeDomSerializer, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+     [SRDescriptionAttribute("DescriptionToolStrip")]
+     public class ToolStrip : ScrollableControl, IArrangedElement, IComponent, IDisposable, ISupportToolStripPanel {
++        [BrowsableAttribute(true)]
++        [DefaultValueAttribute(false)]
++        [DesignerSerializationVisibilityAttribute(1)]
++        [EditorBrowsableAttribute(0)]
++        [SRCategoryAttribute("CatBehavior")]
++        [SRDescriptionAttribute("ToolStripAllowClickThrough")]
++        public bool AllowClickThrough { get; set; }
+     }
+     [DefaultEventAttribute("Click")]
+     [DefaultPropertyAttribute("Text")]
+     [DesignTimeVisibleAttribute(false)]
+     [DesignerAttribute("System.Windows.Forms.Design.ToolStripItemDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
+     [ToolboxItemAttribute(false)]
+     public abstract class ToolStripItem : BindableComponent, IArrangedElement, ICommandBindingTargetProvider, IComponent, IDisposable, IDropTarget, IKeyboardToolTip, ISupportOleDropSource {
++        protected internal virtual ToolStripRenderer Renderer { get; }
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/Microsoft.WindowsDesktop.App/9.0-preview7_System.Windows.md

@@ -0,0 +1,78 @@
+# System.Windows
+
+``` diff
+ namespace System.Windows {
+     public class Application : DispatcherObject, IQueryAmbient {
++        [ExperimentalAttribute("WPF0001")]
++        [TypeConverterAttribute(typeof(ThemeModeConverter))]
++        public ThemeMode ThemeMode { get; set; }
+     }
+-    [XamlSetMarkupExtensionAttribute("ReceiveMarkupExtension")]
+-    [XamlSetTypeConverterAttribute("ReceiveTypeConverter")]
+-    public class Setter : SetterBase, ISupportInitialize
++    [ContentPropertyAttribute("Value")]
++    [XamlSetMarkupExtensionAttribute("ReceiveMarkupExtension")]
++    [XamlSetTypeConverterAttribute("ReceiveTypeConverter")]
++    public class Setter : SetterBase, ISupportInitialize
+     public static class SystemColors {
++        public static Color AccentColor { get; }
++        public static SolidColorBrush AccentColorBrush { get; }
++        public static ResourceKey AccentColorBrushKey { get; }
++        public static Color AccentColorDark1 { get; }
++        public static SolidColorBrush AccentColorDark1Brush { get; }
++        public static ResourceKey AccentColorDark1BrushKey { get; }
++        public static ResourceKey AccentColorDark1Key { get; }
++        public static Color AccentColorDark2 { get; }
++        public static SolidColorBrush AccentColorDark2Brush { get; }
++        public static ResourceKey AccentColorDark2BrushKey { get; }
++        public static ResourceKey AccentColorDark2Key { get; }
++        public static Color AccentColorDark3 { get; }
++        public static SolidColorBrush AccentColorDark3Brush { get; }
++        public static ResourceKey AccentColorDark3BrushKey { get; }
++        public static ResourceKey AccentColorDark3Key { get; }
++        public static ResourceKey AccentColorKey { get; }
++        public static Color AccentColorLight1 { get; }
++        public static SolidColorBrush AccentColorLight1Brush { get; }
++        public static ResourceKey AccentColorLight1BrushKey { get; }
++        public static ResourceKey AccentColorLight1Key { get; }
++        public static Color AccentColorLight2 { get; }
++        public static SolidColorBrush AccentColorLight2Brush { get; }
++        public static ResourceKey AccentColorLight2BrushKey { get; }
++        public static ResourceKey AccentColorLight2Key { get; }
++        public static Color AccentColorLight3 { get; }
++        public static SolidColorBrush AccentColorLight3Brush { get; }
++        public static ResourceKey AccentColorLight3BrushKey { get; }
++        public static ResourceKey AccentColorLight3Key { get; }
+     }
++    [ExperimentalAttribute("WPF0001")]
++    public readonly struct ThemeMode : IEquatable<ThemeMode> {
++        public ThemeMode(string value);
++        public static ThemeMode Dark { get; }
++        public static ThemeMode Light { get; }
++        public static ThemeMode None { get; }
++        public static ThemeMode System { get; }
++        public string Value { get; }
++        public override bool Equals(object obj);
++        public bool Equals(ThemeMode other);
++        public override int GetHashCode();
++        public static bool operator ==(ThemeMode left, ThemeMode right);
++        public static bool operator !=(ThemeMode left, ThemeMode right);
++        public override string ToString();
++    }
++    [ExperimentalAttribute("WPF0001")]
++    public class ThemeModeConverter : TypeConverter {
++        public ThemeModeConverter();
++        public override bool CanConvertFrom(ITypeDescriptorContext typeDescriptorContext, Type sourceType);
++        public override bool CanConvertTo(ITypeDescriptorContext typeDescriptorContext, Type destinationType);
++        public override object ConvertFrom(ITypeDescriptorContext typeDescriptorContext, CultureInfo cultureInfo, object source);
++        public override object ConvertTo(ITypeDescriptorContext typeDescriptorContext, CultureInfo cultureInfo, object value, Type destinationType);
++    }
+     [LocalizabilityAttribute(LocalizationCategory.Ignore)]
+     public class Window : ContentControl {
++        [ExperimentalAttribute("WPF0001")]
++        [TypeConverterAttribute(typeof(ThemeModeConverter))]
++        public ThemeMode ThemeMode { get; set; }
+     }
+ }
+```
+

release-notes/9.0/preview/preview7/api-diff/README.md

@@ -0,0 +1,7 @@
+# .NET 9.0 Preview 7 API Changes
+
+The following API changes were made in .NET 9.0 Preview 7:
+
+- [Microsoft.NETCore.App](./Microsoft.NETCore.App/9.0-preview7.md)
+- [Microsoft.AspNetCore.App](./Microsoft.AspNetCore.App/9.0-preview7.md)
+- [Microsoft.WindowsDesktop.App](./Microsoft.WindowsDesktop.App/9.0-preview7.md)