diff --git a/src/referencePackages/src/system.buffers/4.6.1/System.Buffers.4.6.1.csproj b/src/referencePackages/src/system.buffers/4.6.1/System.Buffers.4.6.1.csproj new file mode 100644 index 0000000000..6773db7c13 --- /dev/null +++ b/src/referencePackages/src/system.buffers/4.6.1/System.Buffers.4.6.1.csproj @@ -0,0 +1,10 @@ + + + + netstandard2.0 + 4.6.1 + System.Buffers + Open + + + diff --git a/src/referencePackages/src/system.buffers/4.6.1/lib/netstandard2.0/System.Buffers.cs b/src/referencePackages/src/system.buffers/4.6.1/lib/netstandard2.0/System.Buffers.cs new file mode 100644 index 0000000000..2b0981ed03 --- /dev/null +++ b/src/referencePackages/src/system.buffers/4.6.1/lib/netstandard2.0/System.Buffers.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Buffers")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Buffers")] +[assembly: System.Reflection.AssemblyFileVersion("4.600.125.16908")] +[assembly: System.Reflection.AssemblyInformationalVersion("4.6.1+6b84308c9ad012f53240d72c1d716d7e42546483")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Buffers")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("4.0.2.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Buffers +{ + public abstract partial class ArrayPool + { + public static ArrayPool Shared { get { throw null; } } + + public static ArrayPool Create() { throw null; } + + public static ArrayPool Create(int maxArrayLength, int maxArraysPerBucket) { throw null; } + + public abstract T[] Rent(int minimumLength); + public abstract void Return(T[] array, bool clearArray = false); + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.buffers/4.6.1/lib/netstandard2.1/_._ b/src/referencePackages/src/system.buffers/4.6.1/lib/netstandard2.1/_._ new file mode 100755 index 0000000000..e69de29bb2 diff --git a/src/referencePackages/src/system.buffers/4.6.1/system.buffers.nuspec b/src/referencePackages/src/system.buffers/4.6.1/system.buffers.nuspec new file mode 100644 index 0000000000..577e8fe388 --- /dev/null +++ b/src/referencePackages/src/system.buffers/4.6.1/system.buffers.nuspec @@ -0,0 +1,20 @@ + + + + System.Buffers + 4.6.1 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Buffers + © Microsoft Corporation. All rights reserved. + true + + + + + + + \ No newline at end of file diff --git a/src/referencePackages/src/system.memory/4.6.2/System.Memory.4.6.2.csproj b/src/referencePackages/src/system.memory/4.6.2/System.Memory.4.6.2.csproj new file mode 100644 index 0000000000..6b13748610 --- /dev/null +++ b/src/referencePackages/src/system.memory/4.6.2/System.Memory.4.6.2.csproj @@ -0,0 +1,16 @@ + + + + netstandard2.0 + 4.6.2 + System.Memory + Open + + + + + + + + + diff --git a/src/referencePackages/src/system.memory/4.6.2/lib/netstandard2.0/System.Memory.cs b/src/referencePackages/src/system.memory/4.6.2/lib/netstandard2.0/System.Memory.cs new file mode 100644 index 0000000000..93a0295d01 --- /dev/null +++ b/src/referencePackages/src/system.memory/4.6.2/lib/netstandard2.0/System.Memory.cs @@ -0,0 +1,941 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Memory")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Memory")] +[assembly: System.Reflection.AssemblyFileVersion("4.600.225.16908")] +[assembly: System.Reflection.AssemblyInformationalVersion("4.6.2+6b84308c9ad012f53240d72c1d716d7e42546483")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Memory")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("4.0.2.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System +{ + public static partial class MemoryExtensions + { + public static ReadOnlyMemory AsMemory(this string text, int start, int length) { throw null; } + + public static ReadOnlyMemory AsMemory(this string text, int start) { throw null; } + + public static ReadOnlyMemory AsMemory(this string text) { throw null; } + + public static Memory AsMemory(this T[] array, int start, int length) { throw null; } + + public static Memory AsMemory(this T[] array, int start) { throw null; } + + public static Memory AsMemory(this T[] array) { throw null; } + + public static Memory AsMemory(this ArraySegment segment, int start, int length) { throw null; } + + public static Memory AsMemory(this ArraySegment segment, int start) { throw null; } + + public static Memory AsMemory(this ArraySegment segment) { throw null; } + + public static ReadOnlySpan AsSpan(this string text, int start, int length) { throw null; } + + public static ReadOnlySpan AsSpan(this string text, int start) { throw null; } + + public static ReadOnlySpan AsSpan(this string text) { throw null; } + + public static Span AsSpan(this T[] array, int start, int length) { throw null; } + + public static Span AsSpan(this T[] array, int start) { throw null; } + + public static Span AsSpan(this T[] array) { throw null; } + + public static Span AsSpan(this ArraySegment segment, int start, int length) { throw null; } + + public static Span AsSpan(this ArraySegment segment, int start) { throw null; } + + public static Span AsSpan(this ArraySegment segment) { throw null; } + + public static int BinarySearch(this ReadOnlySpan span, IComparable comparable) { throw null; } + + public static int BinarySearch(this Span span, IComparable comparable) { throw null; } + + public static int BinarySearch(this ReadOnlySpan span, T value, TComparer comparer) + where TComparer : Collections.Generic.IComparer { throw null; } + + public static int BinarySearch(this ReadOnlySpan span, TComparable comparable) + where TComparable : IComparable { throw null; } + + public static int BinarySearch(this Span span, T value, TComparer comparer) + where TComparer : Collections.Generic.IComparer { throw null; } + + public static int BinarySearch(this Span span, TComparable comparable) + where TComparable : IComparable { throw null; } + + public static int CompareTo(this ReadOnlySpan span, ReadOnlySpan other, StringComparison comparisonType) { throw null; } + + public static bool Contains(this ReadOnlySpan span, ReadOnlySpan value, StringComparison comparisonType) { throw null; } + + public static void CopyTo(this T[] source, Memory destination) { } + + public static void CopyTo(this T[] source, Span destination) { } + + public static bool EndsWith(this ReadOnlySpan span, ReadOnlySpan value, StringComparison comparisonType) { throw null; } + + public static bool EndsWith(this ReadOnlySpan span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static bool EndsWith(this Span span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static bool Equals(this ReadOnlySpan span, ReadOnlySpan other, StringComparison comparisonType) { throw null; } + + public static int IndexOf(this ReadOnlySpan span, ReadOnlySpan value, StringComparison comparisonType) { throw null; } + + public static int IndexOf(this ReadOnlySpan span, T value) + where T : IEquatable { throw null; } + + public static int IndexOf(this ReadOnlySpan span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int IndexOf(this Span span, T value) + where T : IEquatable { throw null; } + + public static int IndexOf(this Span span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this ReadOnlySpan span, T value0, T value1, T value2) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this ReadOnlySpan span, T value0, T value1) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this ReadOnlySpan span, ReadOnlySpan values) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this Span span, T value0, T value1, T value2) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this Span span, T value0, T value1) + where T : IEquatable { throw null; } + + public static int IndexOfAny(this Span span, ReadOnlySpan values) + where T : IEquatable { throw null; } + + public static bool IsWhiteSpace(this ReadOnlySpan span) { throw null; } + + public static int LastIndexOf(this ReadOnlySpan span, T value) + where T : IEquatable { throw null; } + + public static int LastIndexOf(this ReadOnlySpan span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int LastIndexOf(this Span span, T value) + where T : IEquatable { throw null; } + + public static int LastIndexOf(this Span span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this ReadOnlySpan span, T value0, T value1, T value2) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this ReadOnlySpan span, T value0, T value1) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this ReadOnlySpan span, ReadOnlySpan values) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this Span span, T value0, T value1, T value2) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this Span span, T value0, T value1) + where T : IEquatable { throw null; } + + public static int LastIndexOfAny(this Span span, ReadOnlySpan values) + where T : IEquatable { throw null; } + + public static bool Overlaps(this ReadOnlySpan span, ReadOnlySpan other, out int elementOffset) { throw null; } + + public static bool Overlaps(this ReadOnlySpan span, ReadOnlySpan other) { throw null; } + + public static bool Overlaps(this Span span, ReadOnlySpan other, out int elementOffset) { throw null; } + + public static bool Overlaps(this Span span, ReadOnlySpan other) { throw null; } + + public static void Reverse(this Span span) { } + + public static int SequenceCompareTo(this ReadOnlySpan span, ReadOnlySpan other) + where T : IComparable { throw null; } + + public static int SequenceCompareTo(this Span span, ReadOnlySpan other) + where T : IComparable { throw null; } + + public static bool SequenceEqual(this ReadOnlySpan span, ReadOnlySpan other) + where T : IEquatable { throw null; } + + public static bool SequenceEqual(this Span span, ReadOnlySpan other) + where T : IEquatable { throw null; } + + public static bool StartsWith(this ReadOnlySpan span, ReadOnlySpan value, StringComparison comparisonType) { throw null; } + + public static bool StartsWith(this ReadOnlySpan span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static bool StartsWith(this Span span, ReadOnlySpan value) + where T : IEquatable { throw null; } + + public static int ToLower(this ReadOnlySpan source, Span destination, Globalization.CultureInfo culture) { throw null; } + + public static int ToLowerInvariant(this ReadOnlySpan source, Span destination) { throw null; } + + public static int ToUpper(this ReadOnlySpan source, Span destination, Globalization.CultureInfo culture) { throw null; } + + public static int ToUpperInvariant(this ReadOnlySpan source, Span destination) { throw null; } + + public static ReadOnlySpan Trim(this ReadOnlySpan span, char trimChar) { throw null; } + + public static ReadOnlySpan Trim(this ReadOnlySpan span, ReadOnlySpan trimChars) { throw null; } + + public static ReadOnlySpan Trim(this ReadOnlySpan span) { throw null; } + + public static ReadOnlySpan TrimEnd(this ReadOnlySpan span, char trimChar) { throw null; } + + public static ReadOnlySpan TrimEnd(this ReadOnlySpan span, ReadOnlySpan trimChars) { throw null; } + + public static ReadOnlySpan TrimEnd(this ReadOnlySpan span) { throw null; } + + public static ReadOnlySpan TrimStart(this ReadOnlySpan span, char trimChar) { throw null; } + + public static ReadOnlySpan TrimStart(this ReadOnlySpan span, ReadOnlySpan trimChars) { throw null; } + + public static ReadOnlySpan TrimStart(this ReadOnlySpan span) { throw null; } + } + + public readonly partial struct Memory + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public Memory(T[] array, int start, int length) { } + + public Memory(T[] array) { } + + public static Memory Empty { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public int Length { get { throw null; } } + + public Span Span { get { throw null; } } + + public readonly void CopyTo(Memory destination) { } + + public readonly bool Equals(Memory other) { throw null; } + + public override readonly bool Equals(object obj) { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static implicit operator Memory(T[] array) { throw null; } + + public static implicit operator Memory(ArraySegment segment) { throw null; } + + public static implicit operator ReadOnlyMemory(Memory memory) { throw null; } + + public readonly Buffers.MemoryHandle Pin() { throw null; } + + public readonly Memory Slice(int start, int length) { throw null; } + + public readonly Memory Slice(int start) { throw null; } + + public readonly T[] ToArray() { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryCopyTo(Memory destination) { throw null; } + } + + public readonly partial struct ReadOnlyMemory + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public ReadOnlyMemory(T[] array, int start, int length) { } + + public ReadOnlyMemory(T[] array) { } + + public static ReadOnlyMemory Empty { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public int Length { get { throw null; } } + + public ReadOnlySpan Span { get { throw null; } } + + public readonly void CopyTo(Memory destination) { } + + public override readonly bool Equals(object obj) { throw null; } + + public readonly bool Equals(ReadOnlyMemory other) { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static implicit operator ReadOnlyMemory(T[] array) { throw null; } + + public static implicit operator ReadOnlyMemory(ArraySegment segment) { throw null; } + + public readonly Buffers.MemoryHandle Pin() { throw null; } + + public readonly ReadOnlyMemory Slice(int start, int length) { throw null; } + + public readonly ReadOnlyMemory Slice(int start) { throw null; } + + public readonly T[] ToArray() { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryCopyTo(Memory destination) { throw null; } + } + + public readonly ref partial struct ReadOnlySpan + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public ReadOnlySpan(T[] array, int start, int length) { } + + public ReadOnlySpan(T[] array) { } + + [CLSCompliant(false)] + public unsafe ReadOnlySpan(void* pointer, int length) { } + + public static ReadOnlySpan Empty { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public ref readonly T this[int index] { get { throw null; } } + + public int Length { get { throw null; } } + + public readonly void CopyTo(Span destination) { } + + [Obsolete("Equals() on ReadOnlySpan will always throw an exception. Use == instead.")] + public override readonly bool Equals(object obj) { throw null; } + + public readonly Enumerator GetEnumerator() { throw null; } + + [Obsolete("GetHashCode() on ReadOnlySpan will always throw an exception.")] + public override readonly int GetHashCode() { throw null; } + + public readonly ref readonly T GetPinnableReference() { throw null; } + + public static bool operator ==(ReadOnlySpan left, ReadOnlySpan right) { throw null; } + + public static implicit operator ReadOnlySpan(T[] array) { throw null; } + + public static implicit operator ReadOnlySpan(ArraySegment segment) { throw null; } + + public static bool operator !=(ReadOnlySpan left, ReadOnlySpan right) { throw null; } + + public readonly ReadOnlySpan Slice(int start, int length) { throw null; } + + public readonly ReadOnlySpan Slice(int start) { throw null; } + + public readonly T[] ToArray() { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryCopyTo(Span destination) { throw null; } + + public ref partial struct Enumerator + { + private ReadOnlySpan _span; + private object _dummy; + private int _dummyPrimitive; + public ref readonly T Current { get { throw null; } } + + public bool MoveNext() { throw null; } + } + } + + public readonly partial struct SequencePosition : IEquatable + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public SequencePosition(object @object, int integer) { } + + public override readonly bool Equals(object obj) { throw null; } + + public readonly bool Equals(SequencePosition other) { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public readonly int GetInteger() { throw null; } + + public readonly object GetObject() { throw null; } + } + + public readonly ref partial struct Span + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public Span(T[] array, int start, int length) { } + + public Span(T[] array) { } + + [CLSCompliant(false)] + public unsafe Span(void* pointer, int length) { } + + public static Span Empty { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public ref T this[int index] { get { throw null; } } + + public int Length { get { throw null; } } + + public readonly void Clear() { } + + public readonly void CopyTo(Span destination) { } + + [Obsolete("Equals() on Span will always throw an exception. Use == instead.")] + public override readonly bool Equals(object obj) { throw null; } + + public readonly void Fill(T value) { } + + public readonly Enumerator GetEnumerator() { throw null; } + + [Obsolete("GetHashCode() on Span will always throw an exception.")] + public override readonly int GetHashCode() { throw null; } + + public readonly ref T GetPinnableReference() { throw null; } + + public static bool operator ==(Span left, Span right) { throw null; } + + public static implicit operator Span(T[] array) { throw null; } + + public static implicit operator Span(ArraySegment segment) { throw null; } + + public static implicit operator ReadOnlySpan(Span span) { throw null; } + + public static bool operator !=(Span left, Span right) { throw null; } + + public readonly Span Slice(int start, int length) { throw null; } + + public readonly Span Slice(int start) { throw null; } + + public readonly T[] ToArray() { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryCopyTo(Span destination) { throw null; } + + public ref partial struct Enumerator + { + private Span _span; + private object _dummy; + private int _dummyPrimitive; + public ref T Current { get { throw null; } } + + public bool MoveNext() { throw null; } + } + } +} + +namespace System.Buffers +{ + public static partial class BuffersExtensions + { + public static void CopyTo(this in ReadOnlySequence source, Span destination) { } + + public static SequencePosition? PositionOf(this in ReadOnlySequence source, T value) + where T : IEquatable { throw null; } + + public static T[] ToArray(this in ReadOnlySequence sequence) { throw null; } + + public static void Write(this IBufferWriter writer, ReadOnlySpan value) { } + } + + public partial interface IBufferWriter + { + void Advance(int count); + Memory GetMemory(int sizeHint = 0); + Span GetSpan(int sizeHint = 0); + } + + public partial interface IMemoryOwner : IDisposable + { + Memory Memory { get; } + } + + public partial interface IPinnable + { + MemoryHandle Pin(int elementIndex); + void Unpin(); + } + + public partial struct MemoryHandle : IDisposable + { + private object _dummy; + private int _dummyPrimitive; + [CLSCompliant(false)] + public unsafe MemoryHandle(void* pointer, Runtime.InteropServices.GCHandle handle = default, IPinnable pinnable = null) { } + + [CLSCompliant(false)] + public unsafe void* Pointer { get { throw null; } } + + public void Dispose() { } + } + + public abstract partial class MemoryManager : IMemoryOwner, IDisposable, IPinnable + { + public virtual Memory Memory { get { throw null; } } + + protected Memory CreateMemory(int start, int length) { throw null; } + + protected Memory CreateMemory(int length) { throw null; } + + protected abstract void Dispose(bool disposing); + public abstract Span GetSpan(); + public abstract MemoryHandle Pin(int elementIndex = 0); + void IDisposable.Dispose() { } + + protected internal virtual bool TryGetArray(out ArraySegment segment) { throw null; } + + public abstract void Unpin(); + } + + public abstract partial class MemoryPool : IDisposable + { + public abstract int MaxBufferSize { get; } + + public static MemoryPool Shared { get { throw null; } } + + public void Dispose() { } + + protected abstract void Dispose(bool disposing); + public abstract IMemoryOwner Rent(int minBufferSize = -1); + } + + public enum OperationStatus + { + Done = 0, + DestinationTooSmall = 1, + NeedMoreData = 2, + InvalidData = 3 + } + + public abstract partial class ReadOnlySequenceSegment + { + public ReadOnlyMemory Memory { get { throw null; } protected set { } } + + public ReadOnlySequenceSegment Next { get { throw null; } protected set { } } + + public long RunningIndex { get { throw null; } protected set { } } + } + + public readonly partial struct ReadOnlySequence + { + public static readonly ReadOnlySequence Empty; + public ReadOnlySequence(T[] array, int start, int length) { } + + public ReadOnlySequence(T[] array) { } + + public ReadOnlySequence(ReadOnlySequenceSegment startSegment, int startIndex, ReadOnlySequenceSegment endSegment, int endIndex) { } + + public ReadOnlySequence(ReadOnlyMemory memory) { } + + public SequencePosition End { get { throw null; } } + + public ReadOnlyMemory First { get { throw null; } } + + public bool IsEmpty { get { throw null; } } + + public bool IsSingleSegment { get { throw null; } } + + public long Length { get { throw null; } } + + public SequencePosition Start { get { throw null; } } + + public readonly Enumerator GetEnumerator() { throw null; } + + public readonly SequencePosition GetPosition(long offset, SequencePosition origin) { throw null; } + + public readonly SequencePosition GetPosition(long offset) { throw null; } + + public readonly ReadOnlySequence Slice(int start, int length) { throw null; } + + public readonly ReadOnlySequence Slice(int start, SequencePosition end) { throw null; } + + public readonly ReadOnlySequence Slice(long start, long length) { throw null; } + + public readonly ReadOnlySequence Slice(long start, SequencePosition end) { throw null; } + + public readonly ReadOnlySequence Slice(long start) { throw null; } + + public readonly ReadOnlySequence Slice(SequencePosition start, int length) { throw null; } + + public readonly ReadOnlySequence Slice(SequencePosition start, long length) { throw null; } + + public readonly ReadOnlySequence Slice(SequencePosition start, SequencePosition end) { throw null; } + + public readonly ReadOnlySequence Slice(SequencePosition start) { throw null; } + + public override readonly string ToString() { throw null; } + + public readonly bool TryGet(ref SequencePosition position, out ReadOnlyMemory memory, bool advance = true) { throw null; } + + public partial struct Enumerator + { + private ReadOnlySequence _sequence; + private ReadOnlyMemory _currentMemory; + private int _dummyPrimitive; + public Enumerator(in ReadOnlySequence sequence) { } + + public ReadOnlyMemory Current { get { throw null; } } + + public bool MoveNext() { throw null; } + } + } + + public readonly partial struct StandardFormat : IEquatable + { + private readonly int _dummyPrimitive; + public const byte MaxPrecision = 99; + public const byte NoPrecision = 255; + public StandardFormat(char symbol, byte precision = 255) { } + + public bool HasPrecision { get { throw null; } } + + public bool IsDefault { get { throw null; } } + + public byte Precision { get { throw null; } } + + public char Symbol { get { throw null; } } + + public readonly bool Equals(StandardFormat other) { throw null; } + + public override readonly bool Equals(object obj) { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static bool operator ==(StandardFormat left, StandardFormat right) { throw null; } + + public static implicit operator StandardFormat(char symbol) { throw null; } + + public static bool operator !=(StandardFormat left, StandardFormat right) { throw null; } + + public static StandardFormat Parse(ReadOnlySpan format) { throw null; } + + public static StandardFormat Parse(string format) { throw null; } + + public override readonly string ToString() { throw null; } + } +} + +namespace System.Buffers.Binary +{ + public static partial class BinaryPrimitives + { + public static short ReadInt16BigEndian(ReadOnlySpan source) { throw null; } + + public static short ReadInt16LittleEndian(ReadOnlySpan source) { throw null; } + + public static int ReadInt32BigEndian(ReadOnlySpan source) { throw null; } + + public static int ReadInt32LittleEndian(ReadOnlySpan source) { throw null; } + + public static long ReadInt64BigEndian(ReadOnlySpan source) { throw null; } + + public static long ReadInt64LittleEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static ushort ReadUInt16BigEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static ushort ReadUInt16LittleEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static uint ReadUInt32BigEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static uint ReadUInt32LittleEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static ulong ReadUInt64BigEndian(ReadOnlySpan source) { throw null; } + + [CLSCompliant(false)] + public static ulong ReadUInt64LittleEndian(ReadOnlySpan source) { throw null; } + + public static byte ReverseEndianness(byte value) { throw null; } + + public static short ReverseEndianness(short value) { throw null; } + + public static int ReverseEndianness(int value) { throw null; } + + public static long ReverseEndianness(long value) { throw null; } + + [CLSCompliant(false)] + public static sbyte ReverseEndianness(sbyte value) { throw null; } + + [CLSCompliant(false)] + public static ushort ReverseEndianness(ushort value) { throw null; } + + [CLSCompliant(false)] + public static uint ReverseEndianness(uint value) { throw null; } + + [CLSCompliant(false)] + public static ulong ReverseEndianness(ulong value) { throw null; } + + public static bool TryReadInt16BigEndian(ReadOnlySpan source, out short value) { throw null; } + + public static bool TryReadInt16LittleEndian(ReadOnlySpan source, out short value) { throw null; } + + public static bool TryReadInt32BigEndian(ReadOnlySpan source, out int value) { throw null; } + + public static bool TryReadInt32LittleEndian(ReadOnlySpan source, out int value) { throw null; } + + public static bool TryReadInt64BigEndian(ReadOnlySpan source, out long value) { throw null; } + + public static bool TryReadInt64LittleEndian(ReadOnlySpan source, out long value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt16BigEndian(ReadOnlySpan source, out ushort value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt16LittleEndian(ReadOnlySpan source, out ushort value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt32BigEndian(ReadOnlySpan source, out uint value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt32LittleEndian(ReadOnlySpan source, out uint value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt64BigEndian(ReadOnlySpan source, out ulong value) { throw null; } + + [CLSCompliant(false)] + public static bool TryReadUInt64LittleEndian(ReadOnlySpan source, out ulong value) { throw null; } + + public static bool TryWriteInt16BigEndian(Span destination, short value) { throw null; } + + public static bool TryWriteInt16LittleEndian(Span destination, short value) { throw null; } + + public static bool TryWriteInt32BigEndian(Span destination, int value) { throw null; } + + public static bool TryWriteInt32LittleEndian(Span destination, int value) { throw null; } + + public static bool TryWriteInt64BigEndian(Span destination, long value) { throw null; } + + public static bool TryWriteInt64LittleEndian(Span destination, long value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt16BigEndian(Span destination, ushort value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt16LittleEndian(Span destination, ushort value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt32BigEndian(Span destination, uint value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt32LittleEndian(Span destination, uint value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt64BigEndian(Span destination, ulong value) { throw null; } + + [CLSCompliant(false)] + public static bool TryWriteUInt64LittleEndian(Span destination, ulong value) { throw null; } + + public static void WriteInt16BigEndian(Span destination, short value) { } + + public static void WriteInt16LittleEndian(Span destination, short value) { } + + public static void WriteInt32BigEndian(Span destination, int value) { } + + public static void WriteInt32LittleEndian(Span destination, int value) { } + + public static void WriteInt64BigEndian(Span destination, long value) { } + + public static void WriteInt64LittleEndian(Span destination, long value) { } + + [CLSCompliant(false)] + public static void WriteUInt16BigEndian(Span destination, ushort value) { } + + [CLSCompliant(false)] + public static void WriteUInt16LittleEndian(Span destination, ushort value) { } + + [CLSCompliant(false)] + public static void WriteUInt32BigEndian(Span destination, uint value) { } + + [CLSCompliant(false)] + public static void WriteUInt32LittleEndian(Span destination, uint value) { } + + [CLSCompliant(false)] + public static void WriteUInt64BigEndian(Span destination, ulong value) { } + + [CLSCompliant(false)] + public static void WriteUInt64LittleEndian(Span destination, ulong value) { } + } +} + +namespace System.Buffers.Text +{ + public static partial class Base64 + { + public static OperationStatus DecodeFromUtf8(ReadOnlySpan utf8, Span bytes, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) { throw null; } + + public static OperationStatus DecodeFromUtf8InPlace(Span buffer, out int bytesWritten) { throw null; } + + public static OperationStatus EncodeToUtf8(ReadOnlySpan bytes, Span utf8, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) { throw null; } + + public static OperationStatus EncodeToUtf8InPlace(Span buffer, int dataLength, out int bytesWritten) { throw null; } + + public static int GetMaxDecodedFromUtf8Length(int length) { throw null; } + + public static int GetMaxEncodedToUtf8Length(int length) { throw null; } + } + + public static partial class Utf8Formatter + { + public static bool TryFormat(bool value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(byte value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(DateTime value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(DateTimeOffset value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(decimal value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(double value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(Guid value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(short value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(int value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(long value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + [CLSCompliant(false)] + public static bool TryFormat(sbyte value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(float value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + public static bool TryFormat(TimeSpan value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + [CLSCompliant(false)] + public static bool TryFormat(ushort value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + [CLSCompliant(false)] + public static bool TryFormat(uint value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + + [CLSCompliant(false)] + public static bool TryFormat(ulong value, Span destination, out int bytesWritten, StandardFormat format = default) { throw null; } + } + + public static partial class Utf8Parser + { + public static bool TryParse(ReadOnlySpan source, out bool value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out byte value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out DateTime value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out DateTimeOffset value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out decimal value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out double value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out Guid value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out short value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out int value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out long value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + [CLSCompliant(false)] + public static bool TryParse(ReadOnlySpan source, out sbyte value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out float value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + public static bool TryParse(ReadOnlySpan source, out TimeSpan value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + [CLSCompliant(false)] + public static bool TryParse(ReadOnlySpan source, out ushort value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + [CLSCompliant(false)] + public static bool TryParse(ReadOnlySpan source, out uint value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + + [CLSCompliant(false)] + public static bool TryParse(ReadOnlySpan source, out ulong value, out int bytesConsumed, char standardFormat = '\0') { throw null; } + } +} + +namespace System.Runtime.InteropServices +{ + public static partial class MemoryMarshal + { + public static ReadOnlySpan AsBytes(ReadOnlySpan span) + where T : struct { throw null; } + + public static Span AsBytes(Span span) + where T : struct { throw null; } + + public static Memory AsMemory(ReadOnlyMemory memory) { throw null; } + + public static ReadOnlySpan Cast(ReadOnlySpan span) + where TFrom : struct where TTo : struct { throw null; } + + public static Span Cast(Span span) + where TFrom : struct where TTo : struct { throw null; } + + public static Memory CreateFromPinnedArray(T[] array, int start, int length) { throw null; } + + public static ref T GetReference(ReadOnlySpan span) { throw null; } + + public static ref T GetReference(Span span) { throw null; } + + public static T Read(ReadOnlySpan source) + where T : struct { throw null; } + + public static Collections.Generic.IEnumerable ToEnumerable(ReadOnlyMemory memory) { throw null; } + + public static bool TryGetArray(ReadOnlyMemory memory, out ArraySegment segment) { throw null; } + + public static bool TryGetMemoryManager(ReadOnlyMemory memory, out TManager manager, out int start, out int length) + where TManager : Buffers.MemoryManager { throw null; } + + public static bool TryGetMemoryManager(ReadOnlyMemory memory, out TManager manager) + where TManager : Buffers.MemoryManager { throw null; } + + public static bool TryGetString(ReadOnlyMemory memory, out string text, out int start, out int length) { throw null; } + + public static bool TryRead(ReadOnlySpan source, out T value) + where T : struct { throw null; } + + public static bool TryWrite(Span destination, ref T value) + where T : struct { throw null; } + + public static void Write(Span destination, ref T value) + where T : struct { } + } + + public static partial class SequenceMarshal + { + public static bool TryGetArray(Buffers.ReadOnlySequence sequence, out ArraySegment segment) { throw null; } + + public static bool TryGetReadOnlyMemory(Buffers.ReadOnlySequence sequence, out ReadOnlyMemory memory) { throw null; } + + public static bool TryGetReadOnlySequenceSegment(Buffers.ReadOnlySequence sequence, out Buffers.ReadOnlySequenceSegment startSegment, out int startIndex, out Buffers.ReadOnlySequenceSegment endSegment, out int endIndex) { throw null; } + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.memory/4.6.2/lib/netstandard2.1/_._ b/src/referencePackages/src/system.memory/4.6.2/lib/netstandard2.1/_._ new file mode 100755 index 0000000000..e69de29bb2 diff --git a/src/referencePackages/src/system.memory/4.6.2/system.memory.nuspec b/src/referencePackages/src/system.memory/4.6.2/system.memory.nuspec new file mode 100644 index 0000000000..126539251e --- /dev/null +++ b/src/referencePackages/src/system.memory/4.6.2/system.memory.nuspec @@ -0,0 +1,24 @@ + + + + System.Memory + 4.6.2 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Memory + © Microsoft Corporation. All rights reserved. + true + + + + + + + + + + + \ No newline at end of file diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/System.Net.WebSockets.WebSocketProtocol.5.1.2.csproj b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/System.Net.WebSockets.WebSocketProtocol.5.1.2.csproj new file mode 100644 index 0000000000..4d4675dc3d --- /dev/null +++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/System.Net.WebSockets.WebSocketProtocol.5.1.2.csproj @@ -0,0 +1,18 @@ + + + + net6.0;netstandard2.0 + 5.1.2 + System.Net.WebSockets.WebSocketProtocol + Open + + + + + + + + + + + diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs new file mode 100644 index 0000000000..ec5db0b039 --- /dev/null +++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/lib/net6.0/System.Net.WebSockets.WebSocketProtocol.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Reflection.AssemblyFileVersion("5.100.225.16908")] +[assembly: System.Reflection.AssemblyInformationalVersion("5.1.2+6b84308c9ad012f53240d72c1d716d7e42546483")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("5.1.2.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Net.WebSockets +{ + public static partial class WebSocketProtocol + { + public static WebSocket CreateFromStream(IO.Stream stream, bool isServer, string? subProtocol, TimeSpan keepAliveInterval) { throw null; } + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs new file mode 100644 index 0000000000..1b9bd2593c --- /dev/null +++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/lib/netstandard2.0/System.Net.WebSockets.WebSocketProtocol.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Reflection.AssemblyFileVersion("5.100.225.16908")] +[assembly: System.Reflection.AssemblyInformationalVersion("5.1.2+6b84308c9ad012f53240d72c1d716d7e42546483")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Net.WebSockets.WebSocketProtocol")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("5.1.2.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Net.WebSockets +{ + public static partial class WebSocketProtocol + { + public static WebSocket CreateFromStream(IO.Stream stream, bool isServer, string? subProtocol, TimeSpan keepAliveInterval) { throw null; } + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/system.net.websockets.websocketprotocol.nuspec b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/system.net.websockets.websocketprotocol.nuspec new file mode 100644 index 0000000000..1e189d5bcb --- /dev/null +++ b/src/referencePackages/src/system.net.websockets.websocketprotocol/5.1.2/system.net.websockets.websocketprotocol.nuspec @@ -0,0 +1,26 @@ + + + + System.Net.WebSockets.WebSocketProtocol + 5.1.2 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Net.WebSockets.WebSocketProtocol + © Microsoft Corporation. All rights reserved. + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/referencePackages/src/system.numerics.vectors/4.6.1/System.Numerics.Vectors.4.6.1.csproj b/src/referencePackages/src/system.numerics.vectors/4.6.1/System.Numerics.Vectors.4.6.1.csproj new file mode 100644 index 0000000000..1fa4cbb370 --- /dev/null +++ b/src/referencePackages/src/system.numerics.vectors/4.6.1/System.Numerics.Vectors.4.6.1.csproj @@ -0,0 +1,9 @@ + + + + netstandard2.0 + 4.6.1 + System.Numerics.Vectors + + + diff --git a/src/referencePackages/src/system.numerics.vectors/4.6.1/lib/netstandard2.0/System.Numerics.Vectors.cs b/src/referencePackages/src/system.numerics.vectors/4.6.1/lib/netstandard2.0/System.Numerics.Vectors.cs new file mode 100644 index 0000000000..9e20e483aa --- /dev/null +++ b/src/referencePackages/src/system.numerics.vectors/4.6.1/lib/netstandard2.0/System.Numerics.Vectors.cs @@ -0,0 +1,999 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Numerics.Vectors")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Numerics.Vectors")] +[assembly: System.Reflection.AssemblyFileVersion("4.600.125.16908")] +[assembly: System.Reflection.AssemblyInformationalVersion("4.6.1+6b84308c9ad012f53240d72c1d716d7e42546483")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Numerics.Vectors")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("4.1.3.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Numerics +{ + public partial struct Matrix3x2 : IEquatable + { + public float M11; + public float M12; + public float M21; + public float M22; + public float M31; + public float M32; + public Matrix3x2(float m11, float m12, float m21, float m22, float m31, float m32) { } + + public static Matrix3x2 Identity { get { throw null; } } + + public bool IsIdentity { get { throw null; } } + + public Vector2 Translation { get { throw null; } set { } } + + public static Matrix3x2 Add(Matrix3x2 value1, Matrix3x2 value2) { throw null; } + + public static Matrix3x2 CreateRotation(float radians, Vector2 centerPoint) { throw null; } + + public static Matrix3x2 CreateRotation(float radians) { throw null; } + + public static Matrix3x2 CreateScale(Vector2 scales, Vector2 centerPoint) { throw null; } + + public static Matrix3x2 CreateScale(Vector2 scales) { throw null; } + + public static Matrix3x2 CreateScale(float scale, Vector2 centerPoint) { throw null; } + + public static Matrix3x2 CreateScale(float xScale, float yScale, Vector2 centerPoint) { throw null; } + + public static Matrix3x2 CreateScale(float xScale, float yScale) { throw null; } + + public static Matrix3x2 CreateScale(float scale) { throw null; } + + public static Matrix3x2 CreateSkew(float radiansX, float radiansY, Vector2 centerPoint) { throw null; } + + public static Matrix3x2 CreateSkew(float radiansX, float radiansY) { throw null; } + + public static Matrix3x2 CreateTranslation(Vector2 position) { throw null; } + + public static Matrix3x2 CreateTranslation(float xPosition, float yPosition) { throw null; } + + public bool Equals(Matrix3x2 other) { throw null; } + + public override bool Equals(object obj) { throw null; } + + public float GetDeterminant() { throw null; } + + public override int GetHashCode() { throw null; } + + public static bool Invert(Matrix3x2 matrix, out Matrix3x2 result) { throw null; } + + public static Matrix3x2 Lerp(Matrix3x2 matrix1, Matrix3x2 matrix2, float amount) { throw null; } + + public static Matrix3x2 Multiply(Matrix3x2 value1, Matrix3x2 value2) { throw null; } + + public static Matrix3x2 Multiply(Matrix3x2 value1, float value2) { throw null; } + + public static Matrix3x2 Negate(Matrix3x2 value) { throw null; } + + public static Matrix3x2 operator +(Matrix3x2 value1, Matrix3x2 value2) { throw null; } + + public static bool operator ==(Matrix3x2 value1, Matrix3x2 value2) { throw null; } + + public static bool operator !=(Matrix3x2 value1, Matrix3x2 value2) { throw null; } + + public static Matrix3x2 operator *(Matrix3x2 value1, Matrix3x2 value2) { throw null; } + + public static Matrix3x2 operator *(Matrix3x2 value1, float value2) { throw null; } + + public static Matrix3x2 operator -(Matrix3x2 value1, Matrix3x2 value2) { throw null; } + + public static Matrix3x2 operator -(Matrix3x2 value) { throw null; } + + public static Matrix3x2 Subtract(Matrix3x2 value1, Matrix3x2 value2) { throw null; } + + public override string ToString() { throw null; } + } + + public partial struct Matrix4x4 : IEquatable + { + public float M11; + public float M12; + public float M13; + public float M14; + public float M21; + public float M22; + public float M23; + public float M24; + public float M31; + public float M32; + public float M33; + public float M34; + public float M41; + public float M42; + public float M43; + public float M44; + public Matrix4x4(Matrix3x2 value) { } + + public Matrix4x4(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44) { } + + public static Matrix4x4 Identity { get { throw null; } } + + public bool IsIdentity { get { throw null; } } + + public Vector3 Translation { get { throw null; } set { } } + + public static Matrix4x4 Add(Matrix4x4 value1, Matrix4x4 value2) { throw null; } + + public static Matrix4x4 CreateBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 cameraUpVector, Vector3 cameraForwardVector) { throw null; } + + public static Matrix4x4 CreateConstrainedBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 rotateAxis, Vector3 cameraForwardVector, Vector3 objectForwardVector) { throw null; } + + public static Matrix4x4 CreateFromAxisAngle(Vector3 axis, float angle) { throw null; } + + public static Matrix4x4 CreateFromQuaternion(Quaternion quaternion) { throw null; } + + public static Matrix4x4 CreateFromYawPitchRoll(float yaw, float pitch, float roll) { throw null; } + + public static Matrix4x4 CreateLookAt(Vector3 cameraPosition, Vector3 cameraTarget, Vector3 cameraUpVector) { throw null; } + + public static Matrix4x4 CreateOrthographic(float width, float height, float zNearPlane, float zFarPlane) { throw null; } + + public static Matrix4x4 CreateOrthographicOffCenter(float left, float right, float bottom, float top, float zNearPlane, float zFarPlane) { throw null; } + + public static Matrix4x4 CreatePerspective(float width, float height, float nearPlaneDistance, float farPlaneDistance) { throw null; } + + public static Matrix4x4 CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float nearPlaneDistance, float farPlaneDistance) { throw null; } + + public static Matrix4x4 CreatePerspectiveOffCenter(float left, float right, float bottom, float top, float nearPlaneDistance, float farPlaneDistance) { throw null; } + + public static Matrix4x4 CreateReflection(Plane value) { throw null; } + + public static Matrix4x4 CreateRotationX(float radians, Vector3 centerPoint) { throw null; } + + public static Matrix4x4 CreateRotationX(float radians) { throw null; } + + public static Matrix4x4 CreateRotationY(float radians, Vector3 centerPoint) { throw null; } + + public static Matrix4x4 CreateRotationY(float radians) { throw null; } + + public static Matrix4x4 CreateRotationZ(float radians, Vector3 centerPoint) { throw null; } + + public static Matrix4x4 CreateRotationZ(float radians) { throw null; } + + public static Matrix4x4 CreateScale(Vector3 scales, Vector3 centerPoint) { throw null; } + + public static Matrix4x4 CreateScale(Vector3 scales) { throw null; } + + public static Matrix4x4 CreateScale(float scale, Vector3 centerPoint) { throw null; } + + public static Matrix4x4 CreateScale(float xScale, float yScale, float zScale, Vector3 centerPoint) { throw null; } + + public static Matrix4x4 CreateScale(float xScale, float yScale, float zScale) { throw null; } + + public static Matrix4x4 CreateScale(float scale) { throw null; } + + public static Matrix4x4 CreateShadow(Vector3 lightDirection, Plane plane) { throw null; } + + public static Matrix4x4 CreateTranslation(Vector3 position) { throw null; } + + public static Matrix4x4 CreateTranslation(float xPosition, float yPosition, float zPosition) { throw null; } + + public static Matrix4x4 CreateWorld(Vector3 position, Vector3 forward, Vector3 up) { throw null; } + + public static bool Decompose(Matrix4x4 matrix, out Vector3 scale, out Quaternion rotation, out Vector3 translation) { throw null; } + + public bool Equals(Matrix4x4 other) { throw null; } + + public override bool Equals(object obj) { throw null; } + + public float GetDeterminant() { throw null; } + + public override int GetHashCode() { throw null; } + + public static bool Invert(Matrix4x4 matrix, out Matrix4x4 result) { throw null; } + + public static Matrix4x4 Lerp(Matrix4x4 matrix1, Matrix4x4 matrix2, float amount) { throw null; } + + public static Matrix4x4 Multiply(Matrix4x4 value1, Matrix4x4 value2) { throw null; } + + public static Matrix4x4 Multiply(Matrix4x4 value1, float value2) { throw null; } + + public static Matrix4x4 Negate(Matrix4x4 value) { throw null; } + + public static Matrix4x4 operator +(Matrix4x4 value1, Matrix4x4 value2) { throw null; } + + public static bool operator ==(Matrix4x4 value1, Matrix4x4 value2) { throw null; } + + public static bool operator !=(Matrix4x4 value1, Matrix4x4 value2) { throw null; } + + public static Matrix4x4 operator *(Matrix4x4 value1, Matrix4x4 value2) { throw null; } + + public static Matrix4x4 operator *(Matrix4x4 value1, float value2) { throw null; } + + public static Matrix4x4 operator -(Matrix4x4 value1, Matrix4x4 value2) { throw null; } + + public static Matrix4x4 operator -(Matrix4x4 value) { throw null; } + + public static Matrix4x4 Subtract(Matrix4x4 value1, Matrix4x4 value2) { throw null; } + + public override string ToString() { throw null; } + + public static Matrix4x4 Transform(Matrix4x4 value, Quaternion rotation) { throw null; } + + public static Matrix4x4 Transpose(Matrix4x4 matrix) { throw null; } + } + + public partial struct Plane : IEquatable + { + public float D; + public Vector3 Normal; + public Plane(Vector3 normal, float d) { } + + public Plane(Vector4 value) { } + + public Plane(float x, float y, float z, float d) { } + + public static Plane CreateFromVertices(Vector3 point1, Vector3 point2, Vector3 point3) { throw null; } + + public static float Dot(Plane plane, Vector4 value) { throw null; } + + public static float DotCoordinate(Plane plane, Vector3 value) { throw null; } + + public static float DotNormal(Plane plane, Vector3 value) { throw null; } + + public bool Equals(Plane other) { throw null; } + + public override bool Equals(object obj) { throw null; } + + public override int GetHashCode() { throw null; } + + public static Plane Normalize(Plane value) { throw null; } + + public static bool operator ==(Plane value1, Plane value2) { throw null; } + + public static bool operator !=(Plane value1, Plane value2) { throw null; } + + public override string ToString() { throw null; } + + public static Plane Transform(Plane plane, Matrix4x4 matrix) { throw null; } + + public static Plane Transform(Plane plane, Quaternion rotation) { throw null; } + } + + public partial struct Quaternion : IEquatable + { + public float W; + public float X; + public float Y; + public float Z; + public Quaternion(Vector3 vectorPart, float scalarPart) { } + + public Quaternion(float x, float y, float z, float w) { } + + public static Quaternion Identity { get { throw null; } } + + public bool IsIdentity { get { throw null; } } + + public static Quaternion Add(Quaternion value1, Quaternion value2) { throw null; } + + public static Quaternion Concatenate(Quaternion value1, Quaternion value2) { throw null; } + + public static Quaternion Conjugate(Quaternion value) { throw null; } + + public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle) { throw null; } + + public static Quaternion CreateFromRotationMatrix(Matrix4x4 matrix) { throw null; } + + public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll) { throw null; } + + public static Quaternion Divide(Quaternion value1, Quaternion value2) { throw null; } + + public static float Dot(Quaternion quaternion1, Quaternion quaternion2) { throw null; } + + public bool Equals(Quaternion other) { throw null; } + + public override bool Equals(object obj) { throw null; } + + public override int GetHashCode() { throw null; } + + public static Quaternion Inverse(Quaternion value) { throw null; } + + public float Length() { throw null; } + + public float LengthSquared() { throw null; } + + public static Quaternion Lerp(Quaternion quaternion1, Quaternion quaternion2, float amount) { throw null; } + + public static Quaternion Multiply(Quaternion value1, Quaternion value2) { throw null; } + + public static Quaternion Multiply(Quaternion value1, float value2) { throw null; } + + public static Quaternion Negate(Quaternion value) { throw null; } + + public static Quaternion Normalize(Quaternion value) { throw null; } + + public static Quaternion operator +(Quaternion value1, Quaternion value2) { throw null; } + + public static Quaternion operator /(Quaternion value1, Quaternion value2) { throw null; } + + public static bool operator ==(Quaternion value1, Quaternion value2) { throw null; } + + public static bool operator !=(Quaternion value1, Quaternion value2) { throw null; } + + public static Quaternion operator *(Quaternion value1, Quaternion value2) { throw null; } + + public static Quaternion operator *(Quaternion value1, float value2) { throw null; } + + public static Quaternion operator -(Quaternion value1, Quaternion value2) { throw null; } + + public static Quaternion operator -(Quaternion value) { throw null; } + + public static Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, float amount) { throw null; } + + public static Quaternion Subtract(Quaternion value1, Quaternion value2) { throw null; } + + public override string ToString() { throw null; } + } + + public static partial class Vector + { + public static bool IsHardwareAccelerated { get { throw null; } } + + public static Vector Abs(Vector value) + where T : struct { throw null; } + + public static Vector Add(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector AndNot(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector AsVectorByte(Vector value) + where T : struct { throw null; } + + public static Vector AsVectorDouble(Vector value) + where T : struct { throw null; } + + public static Vector AsVectorInt16(Vector value) + where T : struct { throw null; } + + public static Vector AsVectorInt32(Vector value) + where T : struct { throw null; } + + public static Vector AsVectorInt64(Vector value) + where T : struct { throw null; } + + [CLSCompliant(false)] + public static Vector AsVectorSByte(Vector value) + where T : struct { throw null; } + + public static Vector AsVectorSingle(Vector value) + where T : struct { throw null; } + + [CLSCompliant(false)] + public static Vector AsVectorUInt16(Vector value) + where T : struct { throw null; } + + [CLSCompliant(false)] + public static Vector AsVectorUInt32(Vector value) + where T : struct { throw null; } + + [CLSCompliant(false)] + public static Vector AsVectorUInt64(Vector value) + where T : struct { throw null; } + + public static Vector BitwiseAnd(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector BitwiseOr(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector ConditionalSelect(Vector condition, Vector left, Vector right) { throw null; } + + public static Vector ConditionalSelect(Vector condition, Vector left, Vector right) { throw null; } + + public static Vector ConditionalSelect(Vector condition, Vector left, Vector right) + where T : struct { throw null; } + + public static Vector ConvertToDouble(Vector value) { throw null; } + + [CLSCompliant(false)] + public static Vector ConvertToDouble(Vector value) { throw null; } + + public static Vector ConvertToInt32(Vector value) { throw null; } + + public static Vector ConvertToInt64(Vector value) { throw null; } + + public static Vector ConvertToSingle(Vector value) { throw null; } + + [CLSCompliant(false)] + public static Vector ConvertToSingle(Vector value) { throw null; } + + [CLSCompliant(false)] + public static Vector ConvertToUInt32(Vector value) { throw null; } + + [CLSCompliant(false)] + public static Vector ConvertToUInt64(Vector value) { throw null; } + + public static Vector Divide(Vector left, Vector right) + where T : struct { throw null; } + + public static T Dot(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector Equals(Vector left, Vector right) { throw null; } + + public static Vector Equals(Vector left, Vector right) { throw null; } + + public static Vector Equals(Vector left, Vector right) { throw null; } + + public static Vector Equals(Vector left, Vector right) { throw null; } + + public static Vector Equals(Vector left, Vector right) + where T : struct { throw null; } + + public static bool EqualsAll(Vector left, Vector right) + where T : struct { throw null; } + + public static bool EqualsAny(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector GreaterThan(Vector left, Vector right) { throw null; } + + public static Vector GreaterThan(Vector left, Vector right) { throw null; } + + public static Vector GreaterThan(Vector left, Vector right) { throw null; } + + public static Vector GreaterThan(Vector left, Vector right) { throw null; } + + public static Vector GreaterThan(Vector left, Vector right) + where T : struct { throw null; } + + public static bool GreaterThanAll(Vector left, Vector right) + where T : struct { throw null; } + + public static bool GreaterThanAny(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector GreaterThanOrEqual(Vector left, Vector right) { throw null; } + + public static Vector GreaterThanOrEqual(Vector left, Vector right) { throw null; } + + public static Vector GreaterThanOrEqual(Vector left, Vector right) { throw null; } + + public static Vector GreaterThanOrEqual(Vector left, Vector right) { throw null; } + + public static Vector GreaterThanOrEqual(Vector left, Vector right) + where T : struct { throw null; } + + public static bool GreaterThanOrEqualAll(Vector left, Vector right) + where T : struct { throw null; } + + public static bool GreaterThanOrEqualAny(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector LessThan(Vector left, Vector right) { throw null; } + + public static Vector LessThan(Vector left, Vector right) { throw null; } + + public static Vector LessThan(Vector left, Vector right) { throw null; } + + public static Vector LessThan(Vector left, Vector right) { throw null; } + + public static Vector LessThan(Vector left, Vector right) + where T : struct { throw null; } + + public static bool LessThanAll(Vector left, Vector right) + where T : struct { throw null; } + + public static bool LessThanAny(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector LessThanOrEqual(Vector left, Vector right) { throw null; } + + public static Vector LessThanOrEqual(Vector left, Vector right) { throw null; } + + public static Vector LessThanOrEqual(Vector left, Vector right) { throw null; } + + public static Vector LessThanOrEqual(Vector left, Vector right) { throw null; } + + public static Vector LessThanOrEqual(Vector left, Vector right) + where T : struct { throw null; } + + public static bool LessThanOrEqualAll(Vector left, Vector right) + where T : struct { throw null; } + + public static bool LessThanOrEqualAny(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector Max(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector Min(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector Multiply(T left, Vector right) + where T : struct { throw null; } + + public static Vector Multiply(Vector left, T right) + where T : struct { throw null; } + + public static Vector Multiply(Vector left, Vector right) + where T : struct { throw null; } + + public static Vector Narrow(Vector low, Vector high) { throw null; } + + [CLSCompliant(false)] + public static Vector Narrow(Vector low, Vector high) { throw null; } + + public static Vector Narrow(Vector low, Vector high) { throw null; } + + public static Vector Narrow(Vector low, Vector high) { throw null; } + + [CLSCompliant(false)] + public static Vector Narrow(Vector low, Vector high) { throw null; } + + [CLSCompliant(false)] + public static Vector Narrow(Vector low, Vector high) { throw null; } + + [CLSCompliant(false)] + public static Vector Narrow(Vector low, Vector high) { throw null; } + + public static Vector Negate(Vector value) + where T : struct { throw null; } + + public static Vector OnesComplement(Vector value) + where T : struct { throw null; } + + public static Vector SquareRoot(Vector value) + where T : struct { throw null; } + + public static Vector Subtract(Vector left, Vector right) + where T : struct { throw null; } + + [CLSCompliant(false)] + public static void Widen(Vector source, out Vector low, out Vector high) { throw null; } + + public static void Widen(Vector source, out Vector low, out Vector high) { throw null; } + + public static void Widen(Vector source, out Vector low, out Vector high) { throw null; } + + [CLSCompliant(false)] + public static void Widen(Vector source, out Vector low, out Vector high) { throw null; } + + public static void Widen(Vector source, out Vector low, out Vector high) { throw null; } + + [CLSCompliant(false)] + public static void Widen(Vector source, out Vector low, out Vector high) { throw null; } + + [CLSCompliant(false)] + public static void Widen(Vector source, out Vector low, out Vector high) { throw null; } + + public static Vector Xor(Vector left, Vector right) + where T : struct { throw null; } + } + + public partial struct Vector2 : IEquatable, IFormattable + { + public float X; + public float Y; + public Vector2(float x, float y) { } + + public Vector2(float value) { } + + public static Vector2 One { get { throw null; } } + + public static Vector2 UnitX { get { throw null; } } + + public static Vector2 UnitY { get { throw null; } } + + public static Vector2 Zero { get { throw null; } } + + public static Vector2 Abs(Vector2 value) { throw null; } + + public static Vector2 Add(Vector2 left, Vector2 right) { throw null; } + + public static Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max) { throw null; } + + public void CopyTo(float[] array, int index) { } + + public void CopyTo(float[] array) { } + + public static float Distance(Vector2 value1, Vector2 value2) { throw null; } + + public static float DistanceSquared(Vector2 value1, Vector2 value2) { throw null; } + + public static Vector2 Divide(Vector2 left, Vector2 right) { throw null; } + + public static Vector2 Divide(Vector2 left, float divisor) { throw null; } + + public static float Dot(Vector2 value1, Vector2 value2) { throw null; } + + public bool Equals(Vector2 other) { throw null; } + + public override bool Equals(object obj) { throw null; } + + public override int GetHashCode() { throw null; } + + public float Length() { throw null; } + + public float LengthSquared() { throw null; } + + public static Vector2 Lerp(Vector2 value1, Vector2 value2, float amount) { throw null; } + + public static Vector2 Max(Vector2 value1, Vector2 value2) { throw null; } + + public static Vector2 Min(Vector2 value1, Vector2 value2) { throw null; } + + public static Vector2 Multiply(Vector2 left, Vector2 right) { throw null; } + + public static Vector2 Multiply(Vector2 left, float right) { throw null; } + + public static Vector2 Multiply(float left, Vector2 right) { throw null; } + + public static Vector2 Negate(Vector2 value) { throw null; } + + public static Vector2 Normalize(Vector2 value) { throw null; } + + public static Vector2 operator +(Vector2 left, Vector2 right) { throw null; } + + public static Vector2 operator /(Vector2 left, Vector2 right) { throw null; } + + public static Vector2 operator /(Vector2 value1, float value2) { throw null; } + + public static bool operator ==(Vector2 left, Vector2 right) { throw null; } + + public static bool operator !=(Vector2 left, Vector2 right) { throw null; } + + public static Vector2 operator *(Vector2 left, Vector2 right) { throw null; } + + public static Vector2 operator *(Vector2 left, float right) { throw null; } + + public static Vector2 operator *(float left, Vector2 right) { throw null; } + + public static Vector2 operator -(Vector2 left, Vector2 right) { throw null; } + + public static Vector2 operator -(Vector2 value) { throw null; } + + public static Vector2 Reflect(Vector2 vector, Vector2 normal) { throw null; } + + public static Vector2 SquareRoot(Vector2 value) { throw null; } + + public static Vector2 Subtract(Vector2 left, Vector2 right) { throw null; } + + public override string ToString() { throw null; } + + public string ToString(string format, IFormatProvider formatProvider) { throw null; } + + public string ToString(string format) { throw null; } + + public static Vector2 Transform(Vector2 position, Matrix3x2 matrix) { throw null; } + + public static Vector2 Transform(Vector2 position, Matrix4x4 matrix) { throw null; } + + public static Vector2 Transform(Vector2 value, Quaternion rotation) { throw null; } + + public static Vector2 TransformNormal(Vector2 normal, Matrix3x2 matrix) { throw null; } + + public static Vector2 TransformNormal(Vector2 normal, Matrix4x4 matrix) { throw null; } + } + + public partial struct Vector3 : IEquatable, IFormattable + { + public float X; + public float Y; + public float Z; + public Vector3(Vector2 value, float z) { } + + public Vector3(float x, float y, float z) { } + + public Vector3(float value) { } + + public static Vector3 One { get { throw null; } } + + public static Vector3 UnitX { get { throw null; } } + + public static Vector3 UnitY { get { throw null; } } + + public static Vector3 UnitZ { get { throw null; } } + + public static Vector3 Zero { get { throw null; } } + + public static Vector3 Abs(Vector3 value) { throw null; } + + public static Vector3 Add(Vector3 left, Vector3 right) { throw null; } + + public static Vector3 Clamp(Vector3 value1, Vector3 min, Vector3 max) { throw null; } + + public void CopyTo(float[] array, int index) { } + + public void CopyTo(float[] array) { } + + public static Vector3 Cross(Vector3 vector1, Vector3 vector2) { throw null; } + + public static float Distance(Vector3 value1, Vector3 value2) { throw null; } + + public static float DistanceSquared(Vector3 value1, Vector3 value2) { throw null; } + + public static Vector3 Divide(Vector3 left, Vector3 right) { throw null; } + + public static Vector3 Divide(Vector3 left, float divisor) { throw null; } + + public static float Dot(Vector3 vector1, Vector3 vector2) { throw null; } + + public bool Equals(Vector3 other) { throw null; } + + public override bool Equals(object obj) { throw null; } + + public override int GetHashCode() { throw null; } + + public float Length() { throw null; } + + public float LengthSquared() { throw null; } + + public static Vector3 Lerp(Vector3 value1, Vector3 value2, float amount) { throw null; } + + public static Vector3 Max(Vector3 value1, Vector3 value2) { throw null; } + + public static Vector3 Min(Vector3 value1, Vector3 value2) { throw null; } + + public static Vector3 Multiply(Vector3 left, Vector3 right) { throw null; } + + public static Vector3 Multiply(Vector3 left, float right) { throw null; } + + public static Vector3 Multiply(float left, Vector3 right) { throw null; } + + public static Vector3 Negate(Vector3 value) { throw null; } + + public static Vector3 Normalize(Vector3 value) { throw null; } + + public static Vector3 operator +(Vector3 left, Vector3 right) { throw null; } + + public static Vector3 operator /(Vector3 left, Vector3 right) { throw null; } + + public static Vector3 operator /(Vector3 value1, float value2) { throw null; } + + public static bool operator ==(Vector3 left, Vector3 right) { throw null; } + + public static bool operator !=(Vector3 left, Vector3 right) { throw null; } + + public static Vector3 operator *(Vector3 left, Vector3 right) { throw null; } + + public static Vector3 operator *(Vector3 left, float right) { throw null; } + + public static Vector3 operator *(float left, Vector3 right) { throw null; } + + public static Vector3 operator -(Vector3 left, Vector3 right) { throw null; } + + public static Vector3 operator -(Vector3 value) { throw null; } + + public static Vector3 Reflect(Vector3 vector, Vector3 normal) { throw null; } + + public static Vector3 SquareRoot(Vector3 value) { throw null; } + + public static Vector3 Subtract(Vector3 left, Vector3 right) { throw null; } + + public override string ToString() { throw null; } + + public string ToString(string format, IFormatProvider formatProvider) { throw null; } + + public string ToString(string format) { throw null; } + + public static Vector3 Transform(Vector3 position, Matrix4x4 matrix) { throw null; } + + public static Vector3 Transform(Vector3 value, Quaternion rotation) { throw null; } + + public static Vector3 TransformNormal(Vector3 normal, Matrix4x4 matrix) { throw null; } + } + + public partial struct Vector4 : IEquatable, IFormattable + { + public float W; + public float X; + public float Y; + public float Z; + public Vector4(Vector2 value, float z, float w) { } + + public Vector4(Vector3 value, float w) { } + + public Vector4(float x, float y, float z, float w) { } + + public Vector4(float value) { } + + public static Vector4 One { get { throw null; } } + + public static Vector4 UnitW { get { throw null; } } + + public static Vector4 UnitX { get { throw null; } } + + public static Vector4 UnitY { get { throw null; } } + + public static Vector4 UnitZ { get { throw null; } } + + public static Vector4 Zero { get { throw null; } } + + public static Vector4 Abs(Vector4 value) { throw null; } + + public static Vector4 Add(Vector4 left, Vector4 right) { throw null; } + + public static Vector4 Clamp(Vector4 value1, Vector4 min, Vector4 max) { throw null; } + + public void CopyTo(float[] array, int index) { } + + public void CopyTo(float[] array) { } + + public static float Distance(Vector4 value1, Vector4 value2) { throw null; } + + public static float DistanceSquared(Vector4 value1, Vector4 value2) { throw null; } + + public static Vector4 Divide(Vector4 left, Vector4 right) { throw null; } + + public static Vector4 Divide(Vector4 left, float divisor) { throw null; } + + public static float Dot(Vector4 vector1, Vector4 vector2) { throw null; } + + public bool Equals(Vector4 other) { throw null; } + + public override bool Equals(object obj) { throw null; } + + public override int GetHashCode() { throw null; } + + public float Length() { throw null; } + + public float LengthSquared() { throw null; } + + public static Vector4 Lerp(Vector4 value1, Vector4 value2, float amount) { throw null; } + + public static Vector4 Max(Vector4 value1, Vector4 value2) { throw null; } + + public static Vector4 Min(Vector4 value1, Vector4 value2) { throw null; } + + public static Vector4 Multiply(Vector4 left, Vector4 right) { throw null; } + + public static Vector4 Multiply(Vector4 left, float right) { throw null; } + + public static Vector4 Multiply(float left, Vector4 right) { throw null; } + + public static Vector4 Negate(Vector4 value) { throw null; } + + public static Vector4 Normalize(Vector4 vector) { throw null; } + + public static Vector4 operator +(Vector4 left, Vector4 right) { throw null; } + + public static Vector4 operator /(Vector4 left, Vector4 right) { throw null; } + + public static Vector4 operator /(Vector4 value1, float value2) { throw null; } + + public static bool operator ==(Vector4 left, Vector4 right) { throw null; } + + public static bool operator !=(Vector4 left, Vector4 right) { throw null; } + + public static Vector4 operator *(Vector4 left, Vector4 right) { throw null; } + + public static Vector4 operator *(Vector4 left, float right) { throw null; } + + public static Vector4 operator *(float left, Vector4 right) { throw null; } + + public static Vector4 operator -(Vector4 left, Vector4 right) { throw null; } + + public static Vector4 operator -(Vector4 value) { throw null; } + + public static Vector4 SquareRoot(Vector4 value) { throw null; } + + public static Vector4 Subtract(Vector4 left, Vector4 right) { throw null; } + + public override string ToString() { throw null; } + + public string ToString(string format, IFormatProvider formatProvider) { throw null; } + + public string ToString(string format) { throw null; } + + public static Vector4 Transform(Vector2 position, Matrix4x4 matrix) { throw null; } + + public static Vector4 Transform(Vector2 value, Quaternion rotation) { throw null; } + + public static Vector4 Transform(Vector3 position, Matrix4x4 matrix) { throw null; } + + public static Vector4 Transform(Vector3 value, Quaternion rotation) { throw null; } + + public static Vector4 Transform(Vector4 vector, Matrix4x4 matrix) { throw null; } + + public static Vector4 Transform(Vector4 value, Quaternion rotation) { throw null; } + } + + public partial struct Vector : IEquatable>, IFormattable where T : struct + { + private int _dummyPrimitive; + public Vector(T value) { } + + public Vector(T[] values, int index) { } + + public Vector(T[] values) { } + + public static int Count { get { throw null; } } + + public T this[int index] { get { throw null; } } + + public static Vector One { get { throw null; } } + + public static Vector Zero { get { throw null; } } + + public void CopyTo(T[] destination, int startIndex) { } + + public void CopyTo(T[] destination) { } + + public bool Equals(Vector other) { throw null; } + + public override bool Equals(object obj) { throw null; } + + public override int GetHashCode() { throw null; } + + public static Vector operator +(Vector left, Vector right) { throw null; } + + public static Vector operator &(Vector left, Vector right) { throw null; } + + public static Vector operator |(Vector left, Vector right) { throw null; } + + public static Vector operator /(Vector left, Vector right) { throw null; } + + public static bool operator ==(Vector left, Vector right) { throw null; } + + public static Vector operator ^(Vector left, Vector right) { throw null; } + + public static explicit operator Vector(Vector value) { throw null; } + + public static explicit operator Vector(Vector value) { throw null; } + + public static explicit operator Vector(Vector value) { throw null; } + + public static explicit operator Vector(Vector value) { throw null; } + + public static explicit operator Vector(Vector value) { throw null; } + + [CLSCompliant(false)] + public static explicit operator Vector(Vector value) { throw null; } + + public static explicit operator Vector(Vector value) { throw null; } + + [CLSCompliant(false)] + public static explicit operator Vector(Vector value) { throw null; } + + [CLSCompliant(false)] + public static explicit operator Vector(Vector value) { throw null; } + + [CLSCompliant(false)] + public static explicit operator Vector(Vector value) { throw null; } + + public static bool operator !=(Vector left, Vector right) { throw null; } + + public static Vector operator *(T factor, Vector value) { throw null; } + + public static Vector operator *(Vector value, T factor) { throw null; } + + public static Vector operator *(Vector left, Vector right) { throw null; } + + public static Vector operator ~(Vector value) { throw null; } + + public static Vector operator -(Vector left, Vector right) { throw null; } + + public static Vector operator -(Vector value) { throw null; } + + public override string ToString() { throw null; } + + public string ToString(string format, IFormatProvider formatProvider) { throw null; } + + public string ToString(string format) { throw null; } + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.numerics.vectors/4.6.1/lib/netstandard2.1/_._ b/src/referencePackages/src/system.numerics.vectors/4.6.1/lib/netstandard2.1/_._ new file mode 100755 index 0000000000..e69de29bb2 diff --git a/src/referencePackages/src/system.numerics.vectors/4.6.1/system.numerics.vectors.nuspec b/src/referencePackages/src/system.numerics.vectors/4.6.1/system.numerics.vectors.nuspec new file mode 100644 index 0000000000..c8a80721d7 --- /dev/null +++ b/src/referencePackages/src/system.numerics.vectors/4.6.1/system.numerics.vectors.nuspec @@ -0,0 +1,20 @@ + + + + System.Numerics.Vectors + 4.6.1 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Numerics.Vectors + © Microsoft Corporation. All rights reserved. + true + + + + + + + \ No newline at end of file diff --git a/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/System.Reflection.DispatchProxy.4.8.2.csproj b/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/System.Reflection.DispatchProxy.4.8.2.csproj new file mode 100644 index 0000000000..d3b6bc8165 --- /dev/null +++ b/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/System.Reflection.DispatchProxy.4.8.2.csproj @@ -0,0 +1,13 @@ + + + + netstandard2.0 + 4.8.2 + System.Reflection.DispatchProxy + + + + + + + diff --git a/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/lib/netstandard2.0/System.Reflection.DispatchProxy.cs b/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/lib/netstandard2.0/System.Reflection.DispatchProxy.cs new file mode 100644 index 0000000000..ce23a665e4 --- /dev/null +++ b/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/lib/netstandard2.0/System.Reflection.DispatchProxy.cs @@ -0,0 +1,37 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Reflection.DispatchProxy")] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Reflection.DispatchProxy")] +[assembly: System.Reflection.AssemblyFileVersion("4.800.225.16908")] +[assembly: System.Reflection.AssemblyInformationalVersion("4.8.2+6b84308c9ad012f53240d72c1d716d7e42546483")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Reflection.DispatchProxy")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("4.0.6.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Reflection +{ + public abstract partial class DispatchProxy + { + public static T Create() + where TProxy : DispatchProxy { throw null; } + + protected abstract object Invoke(MethodInfo targetMethod, object[] args); + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/lib/netstandard2.1/_._ b/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/lib/netstandard2.1/_._ new file mode 100755 index 0000000000..e69de29bb2 diff --git a/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/system.reflection.dispatchproxy.nuspec b/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/system.reflection.dispatchproxy.nuspec new file mode 100644 index 0000000000..a0f736a11a --- /dev/null +++ b/src/referencePackages/src/system.reflection.dispatchproxy/4.8.2/system.reflection.dispatchproxy.nuspec @@ -0,0 +1,22 @@ + + + + System.Reflection.DispatchProxy + 4.8.2 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Reflection.DispatchProxy + © Microsoft Corporation. All rights reserved. + true + + + + + + + + + \ No newline at end of file diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/System.Threading.Tasks.Extensions.4.6.2.csproj b/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/System.Threading.Tasks.Extensions.4.6.2.csproj new file mode 100644 index 0000000000..3a6d2bf920 --- /dev/null +++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/System.Threading.Tasks.Extensions.4.6.2.csproj @@ -0,0 +1,14 @@ + + + + netstandard2.0 + 4.6.2 + System.Threading.Tasks.Extensions + Open + + + + + + + diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs b/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs new file mode 100644 index 0000000000..c2869308f9 --- /dev/null +++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/lib/netstandard2.0/System.Threading.Tasks.Extensions.cs @@ -0,0 +1,268 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ +[assembly: System.Runtime.CompilerServices.CompilationRelaxations(8)] +[assembly: System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = true)] +[assembly: System.Diagnostics.Debuggable(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")] +[assembly: System.CLSCompliant(true)] +[assembly: System.Reflection.AssemblyDefaultAlias("System.Threading.Tasks.Extensions")] +[assembly: System.Runtime.InteropServices.DefaultDllImportSearchPaths(System.Runtime.InteropServices.DllImportSearchPath.AssemblyDirectory | System.Runtime.InteropServices.DllImportSearchPath.System32)] +[assembly: System.Reflection.AssemblyCompany("Microsoft Corporation")] +[assembly: System.Reflection.AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: System.Reflection.AssemblyDescription("System.Threading.Tasks.Extensions")] +[assembly: System.Reflection.AssemblyFileVersion("4.600.225.16908")] +[assembly: System.Reflection.AssemblyInformationalVersion("4.6.2+6b84308c9ad012f53240d72c1d716d7e42546483")] +[assembly: System.Reflection.AssemblyProduct("Microsoft® .NET")] +[assembly: System.Reflection.AssemblyTitle("System.Threading.Tasks.Extensions")] +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/maintenance-packages")] +[assembly: System.Reflection.AssemblyMetadata("PreferInbox", "True")] +[assembly: System.Reflection.AssemblyMetadata("Serviceable", "True")] +[assembly: System.Reflection.AssemblyVersionAttribute("4.2.1.0")] +[assembly: System.Runtime.CompilerServices.ReferenceAssembly] +[assembly: System.Reflection.AssemblyFlagsAttribute((System.Reflection.AssemblyNameFlags)0x70)] +namespace System.Runtime.CompilerServices +{ + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false, AllowMultiple = false)] + public sealed partial class AsyncMethodBuilderAttribute : Attribute + { + public AsyncMethodBuilderAttribute(Type builderType) { } + + public Type BuilderType { get { throw null; } } + } + + public partial struct AsyncValueTaskMethodBuilder + { + private int _dummyPrimitive; + public Threading.Tasks.ValueTask Task { get { throw null; } } + + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { } + + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { } + + public static AsyncValueTaskMethodBuilder Create() { throw null; } + + public void SetException(Exception exception) { } + + public void SetResult() { } + + public void SetStateMachine(IAsyncStateMachine stateMachine) { } + + public void Start(ref TStateMachine stateMachine) + where TStateMachine : IAsyncStateMachine { } + } + + public partial struct AsyncValueTaskMethodBuilder + { + private AsyncTaskMethodBuilder _methodBuilder; + private TResult _result; + private int _dummyPrimitive; + public Threading.Tasks.ValueTask Task { get { throw null; } } + + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine { } + + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) + where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine { } + + public static AsyncValueTaskMethodBuilder Create() { throw null; } + + public void SetException(Exception exception) { } + + public void SetResult(TResult result) { } + + public void SetStateMachine(IAsyncStateMachine stateMachine) { } + + public void Start(ref TStateMachine stateMachine) + where TStateMachine : IAsyncStateMachine { } + } + + public readonly partial struct ConfiguredValueTaskAwaitable + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public readonly ConfiguredValueTaskAwaiter GetAwaiter() { throw null; } + + public readonly partial struct ConfiguredValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public bool IsCompleted { get { throw null; } } + + public readonly void GetResult() { } + + public readonly void OnCompleted(Action continuation) { } + + public readonly void UnsafeOnCompleted(Action continuation) { } + } + } + + public readonly partial struct ConfiguredValueTaskAwaitable + { + private readonly Threading.Tasks.ValueTask _value; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public readonly ConfiguredValueTaskAwaiter GetAwaiter() { throw null; } + + public readonly partial struct ConfiguredValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion + { + private readonly Threading.Tasks.ValueTask _value; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public bool IsCompleted { get { throw null; } } + + public readonly TResult GetResult() { throw null; } + + public readonly void OnCompleted(Action continuation) { } + + public readonly void UnsafeOnCompleted(Action continuation) { } + } + } + + public readonly partial struct ValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public bool IsCompleted { get { throw null; } } + + public readonly void GetResult() { } + + public readonly void OnCompleted(Action continuation) { } + + public readonly void UnsafeOnCompleted(Action continuation) { } + } + + public readonly partial struct ValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion + { + private readonly Threading.Tasks.ValueTask _value; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public bool IsCompleted { get { throw null; } } + + public readonly TResult GetResult() { throw null; } + + public readonly void OnCompleted(Action continuation) { } + + public readonly void UnsafeOnCompleted(Action continuation) { } + } +} + +namespace System.Threading.Tasks +{ + [Runtime.CompilerServices.AsyncMethodBuilder(typeof(Runtime.CompilerServices.AsyncValueTaskMethodBuilder))] + public readonly partial struct ValueTask : IEquatable + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public ValueTask(Sources.IValueTaskSource source, short token) { } + + public ValueTask(Task task) { } + + public bool IsCanceled { get { throw null; } } + + public bool IsCompleted { get { throw null; } } + + public bool IsCompletedSuccessfully { get { throw null; } } + + public bool IsFaulted { get { throw null; } } + + public readonly Task AsTask() { throw null; } + + public readonly Runtime.CompilerServices.ConfiguredValueTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; } + + public override readonly bool Equals(object obj) { throw null; } + + public readonly bool Equals(ValueTask other) { throw null; } + + public readonly Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter() { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static bool operator ==(ValueTask left, ValueTask right) { throw null; } + + public static bool operator !=(ValueTask left, ValueTask right) { throw null; } + + public readonly ValueTask Preserve() { throw null; } + } + + [Runtime.CompilerServices.AsyncMethodBuilder(typeof(Runtime.CompilerServices.AsyncValueTaskMethodBuilder<>))] + public readonly partial struct ValueTask : IEquatable> + { + private readonly TResult _result; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public ValueTask(TResult result) { } + + public ValueTask(Sources.IValueTaskSource source, short token) { } + + public ValueTask(Task task) { } + + public bool IsCanceled { get { throw null; } } + + public bool IsCompleted { get { throw null; } } + + public bool IsCompletedSuccessfully { get { throw null; } } + + public bool IsFaulted { get { throw null; } } + + public TResult Result { get { throw null; } } + + public readonly Task AsTask() { throw null; } + + public readonly Runtime.CompilerServices.ConfiguredValueTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; } + + public override readonly bool Equals(object obj) { throw null; } + + public readonly bool Equals(ValueTask other) { throw null; } + + public readonly Runtime.CompilerServices.ValueTaskAwaiter GetAwaiter() { throw null; } + + public override readonly int GetHashCode() { throw null; } + + public static bool operator ==(ValueTask left, ValueTask right) { throw null; } + + public static bool operator !=(ValueTask left, ValueTask right) { throw null; } + + public readonly ValueTask Preserve() { throw null; } + + public override readonly string ToString() { throw null; } + } +} + +namespace System.Threading.Tasks.Sources +{ + public partial interface IValueTaskSource + { + void GetResult(short token); + ValueTaskSourceStatus GetStatus(short token); + void OnCompleted(Action continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags); + } + + public partial interface IValueTaskSource + { + TResult GetResult(short token); + ValueTaskSourceStatus GetStatus(short token); + void OnCompleted(Action continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags); + } + + [Flags] + public enum ValueTaskSourceOnCompletedFlags + { + None = 0, + UseSchedulingContext = 1, + FlowExecutionContext = 2 + } + + public enum ValueTaskSourceStatus + { + Pending = 0, + Succeeded = 1, + Faulted = 2, + Canceled = 3 + } +} \ No newline at end of file diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/lib/netstandard2.1/_._ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/lib/netstandard2.1/_._ new file mode 100755 index 0000000000..e69de29bb2 diff --git a/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/system.threading.tasks.extensions.nuspec b/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/system.threading.tasks.extensions.nuspec new file mode 100644 index 0000000000..dfcaa05479 --- /dev/null +++ b/src/referencePackages/src/system.threading.tasks.extensions/4.6.2/system.threading.tasks.extensions.nuspec @@ -0,0 +1,22 @@ + + + + System.Threading.Tasks.Extensions + 4.6.2 + Microsoft + true + MIT + https://licenses.nuget.org/MIT + https://github.com/dotnet/maintenance-packages + System.Threading.Tasks.Extensions + © Microsoft Corporation. All rights reserved. + true + + + + + + + + + \ No newline at end of file