Skip to content
Permalink
master
Go to file
 
 
Cannot retrieve contributors at this time
678 lines (677 sloc) 51.5 KB
// 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.
// ------------------------------------------------------------------------------
namespace System
{
public static partial class MemoryExtensions
{
public static System.ReadOnlyMemory<char> AsMemory(this string? text) { throw null; }
public static System.ReadOnlyMemory<char> AsMemory(this string? text, System.Index startIndex) { throw null; }
public static System.ReadOnlyMemory<char> AsMemory(this string? text, int start) { throw null; }
public static System.ReadOnlyMemory<char> AsMemory(this string? text, int start, int length) { throw null; }
public static System.ReadOnlyMemory<char> AsMemory(this string? text, System.Range range) { throw null; }
public static System.Memory<T> AsMemory<T>(this System.ArraySegment<T> segment) { throw null; }
public static System.Memory<T> AsMemory<T>(this System.ArraySegment<T> segment, int start) { throw null; }
public static System.Memory<T> AsMemory<T>(this System.ArraySegment<T> segment, int start, int length) { throw null; }
public static System.Memory<T> AsMemory<T>(this T[]? array) { throw null; }
public static System.Memory<T> AsMemory<T>(this T[]? array, System.Index startIndex) { throw null; }
public static System.Memory<T> AsMemory<T>(this T[]? array, int start) { throw null; }
public static System.Memory<T> AsMemory<T>(this T[]? array, int start, int length) { throw null; }
public static System.Memory<T> AsMemory<T>(this T[]? array, System.Range range) { throw null; }
public static System.ReadOnlySpan<char> AsSpan(this string? text) { throw null; }
public static System.ReadOnlySpan<char> AsSpan(this string? text, int start) { throw null; }
public static System.ReadOnlySpan<char> AsSpan(this string? text, int start, int length) { throw null; }
public static System.Span<T> AsSpan<T>(this System.ArraySegment<T> segment) { throw null; }
public static System.Span<T> AsSpan<T>(this System.ArraySegment<T> segment, System.Index startIndex) { throw null; }
public static System.Span<T> AsSpan<T>(this System.ArraySegment<T> segment, int start) { throw null; }
public static System.Span<T> AsSpan<T>(this System.ArraySegment<T> segment, int start, int length) { throw null; }
public static System.Span<T> AsSpan<T>(this System.ArraySegment<T> segment, System.Range range) { throw null; }
public static System.Span<T> AsSpan<T>(this T[]? array) { throw null; }
public static System.Span<T> AsSpan<T>(this T[]? array, System.Index startIndex) { throw null; }
public static System.Span<T> AsSpan<T>(this T[]? array, int start) { throw null; }
public static System.Span<T> AsSpan<T>(this T[]? array, int start, int length) { throw null; }
public static System.Span<T> AsSpan<T>(this T[]? array, System.Range range) { throw null; }
public static int BinarySearch<T>(this System.ReadOnlySpan<T> span, System.IComparable<T> comparable) { throw null; }
public static int BinarySearch<T>(this System.Span<T> span, System.IComparable<T> comparable) { throw null; }
public static int BinarySearch<T, TComparer>(this System.ReadOnlySpan<T> span, T value, TComparer comparer) where TComparer : System.Collections.Generic.IComparer<T> { throw null; }
public static int BinarySearch<T, TComparable>(this System.ReadOnlySpan<T> span, TComparable comparable) where TComparable : System.IComparable<T> { throw null; }
public static int BinarySearch<T, TComparer>(this System.Span<T> span, T value, TComparer comparer) where TComparer : System.Collections.Generic.IComparer<T> { throw null; }
public static int BinarySearch<T, TComparable>(this System.Span<T> span, TComparable comparable) where TComparable : System.IComparable<T> { throw null; }
public static int CompareTo(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> other, System.StringComparison comparisonType) { throw null; }
public static bool Contains(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
public static bool Contains<T>(this System.ReadOnlySpan<T> span, T value)
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static bool Contains<T>(this System.Span<T> span, T value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static void CopyTo<T>(this T[]? source, System.Memory<T> destination) { }
public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static bool EndsWith(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
public static bool EndsWith<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static bool EndsWith<T>(this System.Span<T> span, System.ReadOnlySpan<T> value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Text.SpanRuneEnumerator EnumerateRunes(this System.ReadOnlySpan<char> span) { throw null; }
public static System.Text.SpanRuneEnumerator EnumerateRunes(this System.Span<char> span) { throw null; }
public static bool Equals(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> other, System.StringComparison comparisonType) { throw null; }
public static int IndexOf(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOfAny<T>(this System.Span<T> span, System.ReadOnlySpan<T> values)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOfAny<T>(this System.Span<T> span, T value0, T value1)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOfAny<T>(this System.Span<T> span, T value0, T value1, T value2)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOf<T>(this System.ReadOnlySpan<T> span, T value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOf<T>(this System.Span<T> span, System.ReadOnlySpan<T> value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int IndexOf<T>(this System.Span<T> span, T value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static bool IsWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static int LastIndexOf(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOfAny<T>(this System.Span<T> span, System.ReadOnlySpan<T> values)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOfAny<T>(this System.Span<T> span, T value0, T value1)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOfAny<T>(this System.Span<T> span, T value0, T value1, T value2)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, T value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOf<T>(this System.Span<T> span, System.ReadOnlySpan<T> value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int LastIndexOf<T>(this System.Span<T> span, T value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static bool Overlaps<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other) { throw null; }
public static bool Overlaps<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other, out int elementOffset) { throw null; }
public static bool Overlaps<T>(this System.Span<T> span, System.ReadOnlySpan<T> other) { throw null; }
public static bool Overlaps<T>(this System.Span<T> span, System.ReadOnlySpan<T> other, out int elementOffset) { throw null; }
public static void Reverse<T>(this System.Span<T> span) { }
public static int SequenceCompareTo<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other) where T : System.IComparable<T> { throw null; }
public static int SequenceCompareTo<T>(this System.Span<T> span, System.ReadOnlySpan<T> other) where T : System.IComparable<T> { throw null; }
public static bool SequenceEqual<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static bool SequenceEqual<T>(this System.Span<T> span, System.ReadOnlySpan<T> other)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static void Sort<T>(this System.Span<T> span) { }
public static void Sort<T, TComparer>(this System.Span<T> span, TComparer comparer) where TComparer : System.Collections.Generic.IComparer<T>? { }
public static void Sort<T>(this System.Span<T> span, System.Comparison<T> comparison) { }
public static void Sort<TKey, TValue>(this System.Span<TKey> keys, System.Span<TValue> items) { }
public static void Sort<TKey, TValue, TComparer>(this System.Span<TKey> keys, System.Span<TValue> items, TComparer comparer) where TComparer : System.Collections.Generic.IComparer<TKey>? { }
public static void Sort<TKey, TValue>(this System.Span<TKey> keys, System.Span<TValue> items, System.Comparison<TKey> comparison) { }
public static bool StartsWith(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
public static bool StartsWith<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static bool StartsWith<T>(this System.Span<T> span, System.ReadOnlySpan<T> value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static int ToLower(this System.ReadOnlySpan<char> source, System.Span<char> destination, System.Globalization.CultureInfo? culture) { throw null; }
public static int ToLowerInvariant(this System.ReadOnlySpan<char> source, System.Span<char> destination) { throw null; }
public static int ToUpper(this System.ReadOnlySpan<char> source, System.Span<char> destination, System.Globalization.CultureInfo? culture) { throw null; }
public static int ToUpperInvariant(this System.ReadOnlySpan<char> source, System.Span<char> destination) { throw null; }
public static System.Memory<char> Trim(this System.Memory<char> memory) { throw null; }
public static System.ReadOnlyMemory<char> Trim(this System.ReadOnlyMemory<char> memory) { throw null; }
public static System.ReadOnlySpan<char> Trim(this System.ReadOnlySpan<char> span) { throw null; }
public static System.ReadOnlySpan<char> Trim(this System.ReadOnlySpan<char> span, char trimChar) { throw null; }
public static System.ReadOnlySpan<char> Trim(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> trimChars) { throw null; }
public static System.Span<char> Trim(this System.Span<char> span) { throw null; }
public static System.Memory<char> TrimEnd(this System.Memory<char> memory) { throw null; }
public static System.ReadOnlyMemory<char> TrimEnd(this System.ReadOnlyMemory<char> memory) { throw null; }
public static System.ReadOnlySpan<char> TrimEnd(this System.ReadOnlySpan<char> span) { throw null; }
public static System.ReadOnlySpan<char> TrimEnd(this System.ReadOnlySpan<char> span, char trimChar) { throw null; }
public static System.ReadOnlySpan<char> TrimEnd(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> trimChars) { throw null; }
public static System.Span<char> TrimEnd(this System.Span<char> span) { throw null; }
public static System.Memory<T> TrimEnd<T>(this System.Memory<T> memory, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Memory<T> TrimEnd<T>(this System.Memory<T> memory, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlyMemory<T> TrimEnd<T>(this System.ReadOnlyMemory<T> memory, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlyMemory<T> TrimEnd<T>(this System.ReadOnlyMemory<T> memory, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlySpan<T> TrimEnd<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlySpan<T> TrimEnd<T>(this System.ReadOnlySpan<T> span, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Span<T> TrimEnd<T>(this System.Span<T> span, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Span<T> TrimEnd<T>(this System.Span<T> span, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Memory<char> TrimStart(this System.Memory<char> memory) { throw null; }
public static System.ReadOnlyMemory<char> TrimStart(this System.ReadOnlyMemory<char> memory) { throw null; }
public static System.ReadOnlySpan<char> TrimStart(this System.ReadOnlySpan<char> span) { throw null; }
public static System.ReadOnlySpan<char> TrimStart(this System.ReadOnlySpan<char> span, char trimChar) { throw null; }
public static System.ReadOnlySpan<char> TrimStart(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> trimChars) { throw null; }
public static System.Span<char> TrimStart(this System.Span<char> span) { throw null; }
public static System.Memory<T> TrimStart<T>(this System.Memory<T> memory, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Memory<T> TrimStart<T>(this System.Memory<T> memory, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlyMemory<T> TrimStart<T>(this System.ReadOnlyMemory<T> memory, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlyMemory<T> TrimStart<T>(this System.ReadOnlyMemory<T> memory, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlySpan<T> TrimStart<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlySpan<T> TrimStart<T>(this System.ReadOnlySpan<T> span, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Span<T> TrimStart<T>(this System.Span<T> span, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Span<T> TrimStart<T>(this System.Span<T> span, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Memory<T> Trim<T>(this System.Memory<T> memory, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Memory<T> Trim<T>(this System.Memory<T> memory, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlyMemory<T> Trim<T>(this System.ReadOnlyMemory<T> memory, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlyMemory<T> Trim<T>(this System.ReadOnlyMemory<T> memory, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlySpan<T> Trim<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.ReadOnlySpan<T> Trim<T>(this System.ReadOnlySpan<T> span, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Span<T> Trim<T>(this System.Span<T> span, System.ReadOnlySpan<T> trimElements)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static System.Span<T> Trim<T>(this System.Span<T> span, T trimElement)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
}
public readonly partial struct SequencePosition : System.IEquatable<System.SequencePosition>
{
private readonly object _dummy;
private readonly int _dummyPrimitive;
public SequencePosition(object? @object, int integer) { throw null; }
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
public override bool Equals(object? obj) { throw null; }
public bool Equals(System.SequencePosition other) { throw null; }
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
public override int GetHashCode() { throw null; }
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
public int GetInteger() { throw null; }
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
public object? GetObject() { throw null; }
}
}
namespace System.Buffers
{
public sealed partial class ArrayBufferWriter<T> : System.Buffers.IBufferWriter<T>
{
public ArrayBufferWriter() { }
public ArrayBufferWriter(int initialCapacity) { }
public int Capacity { get { throw null; } }
public int FreeCapacity { get { throw null; } }
public int WrittenCount { get { throw null; } }
public System.ReadOnlyMemory<T> WrittenMemory { get { throw null; } }
public System.ReadOnlySpan<T> WrittenSpan { get { throw null; } }
public void Advance(int count) { }
public void Clear() { }
public System.Memory<T> GetMemory(int sizeHint = 0) { throw null; }
public System.Span<T> GetSpan(int sizeHint = 0) { throw null; }
}
public static partial class BuffersExtensions
{
public static void CopyTo<T>(this in System.Buffers.ReadOnlySequence<T> source, System.Span<T> destination) { }
public static System.SequencePosition? PositionOf<T>(this in System.Buffers.ReadOnlySequence<T> source, T value)
#nullable disable
where T : System.IEquatable<T> { throw null; }
#nullable restore
public static T[] ToArray<T>(this in System.Buffers.ReadOnlySequence<T> sequence) { throw null; }
public static void Write<T>(this System.Buffers.IBufferWriter<T> writer, System.ReadOnlySpan<T> value) { }
}
public partial interface IBufferWriter<T>
{
void Advance(int count);
System.Memory<T> GetMemory(int sizeHint = 0);
System.Span<T> GetSpan(int sizeHint = 0);
}
public abstract partial class MemoryPool<T> : System.IDisposable
{
protected MemoryPool() { }
public abstract int MaxBufferSize { get; }
public static System.Buffers.MemoryPool<T> Shared { get { throw null; } }
public void Dispose() { }
protected abstract void Dispose(bool disposing);
public abstract System.Buffers.IMemoryOwner<T> Rent(int minBufferSize = -1);
}
public abstract partial class ReadOnlySequenceSegment<T>
{
protected ReadOnlySequenceSegment() { }
public System.ReadOnlyMemory<T> Memory { get { throw null; } protected set { } }
public System.Buffers.ReadOnlySequenceSegment<T>? Next { get { throw null; } protected set { } }
public long RunningIndex { get { throw null; } protected set { } }
}
public readonly partial struct ReadOnlySequence<T>
{
private readonly object _dummy;
private readonly int _dummyPrimitive;
public static readonly System.Buffers.ReadOnlySequence<T> Empty;
public ReadOnlySequence(System.Buffers.ReadOnlySequenceSegment<T> startSegment, int startIndex, System.Buffers.ReadOnlySequenceSegment<T> endSegment, int endIndex) { throw null; }
public ReadOnlySequence(System.ReadOnlyMemory<T> memory) { throw null; }
public ReadOnlySequence(T[] array) { throw null; }
public ReadOnlySequence(T[] array, int start, int length) { throw null; }
public System.SequencePosition End { get { throw null; } }
public System.ReadOnlyMemory<T> First { get { throw null; } }
public System.ReadOnlySpan<T> FirstSpan { get { throw null; } }
public bool IsEmpty { get { throw null; } }
public bool IsSingleSegment { get { throw null; } }
public long Length { get { throw null; } }
public System.SequencePosition Start { get { throw null; } }
public System.Buffers.ReadOnlySequence<T>.Enumerator GetEnumerator() { throw null; }
public System.SequencePosition GetPosition(long offset) { throw null; }
public System.SequencePosition GetPosition(long offset, System.SequencePosition origin) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(int start, int length) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(int start, System.SequencePosition end) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(long start) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(long start, long length) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(long start, System.SequencePosition end) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(System.SequencePosition start) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(System.SequencePosition start, int length) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(System.SequencePosition start, long length) { throw null; }
public System.Buffers.ReadOnlySequence<T> Slice(System.SequencePosition start, System.SequencePosition end) { throw null; }
public override string ToString() { throw null; }
public bool TryGet(ref System.SequencePosition position, out System.ReadOnlyMemory<T> memory, bool advance = true) { throw null; }
public partial struct Enumerator
{
private object _dummy;
private int _dummyPrimitive;
public Enumerator(in System.Buffers.ReadOnlySequence<T> sequence) { throw null; }
public System.ReadOnlyMemory<T> Current { get { throw null; } }
public bool MoveNext() { throw null; }
}
}
public static partial class SequenceReaderExtensions
{
public static bool TryReadBigEndian(this ref System.Buffers.SequenceReader<byte> reader, out short value) { throw null; }
public static bool TryReadBigEndian(this ref System.Buffers.SequenceReader<byte> reader, out int value) { throw null; }
public static bool TryReadBigEndian(this ref System.Buffers.SequenceReader<byte> reader, out long value) { throw null; }
public static bool TryReadLittleEndian(this ref System.Buffers.SequenceReader<byte> reader, out short value) { throw null; }
public static bool TryReadLittleEndian(this ref System.Buffers.SequenceReader<byte> reader, out int value) { throw null; }
public static bool TryReadLittleEndian(this ref System.Buffers.SequenceReader<byte> reader, out long value) { throw null; }
}
public ref partial struct SequenceReader<T> where T : unmanaged, System.IEquatable<T>
{
private object _dummy;
private int _dummyPrimitive;
public SequenceReader(System.Buffers.ReadOnlySequence<T> sequence) { throw null; }
public readonly long Consumed { get { throw null; } }
public readonly System.ReadOnlySpan<T> CurrentSpan { get { throw null; } }
public readonly int CurrentSpanIndex { get { throw null; } }
public readonly bool End { get { throw null; } }
public readonly long Length { get { throw null; } }
public readonly System.SequencePosition Position { get { throw null; } }
public readonly long Remaining { get { throw null; } }
public readonly System.Buffers.ReadOnlySequence<T> Sequence { get { throw null; } }
public readonly System.ReadOnlySpan<T> UnreadSpan { get { throw null; } }
public void Advance(long count) { }
public long AdvancePast(T value) { throw null; }
public long AdvancePastAny(System.ReadOnlySpan<T> values) { throw null; }
public long AdvancePastAny(T value0, T value1) { throw null; }
public long AdvancePastAny(T value0, T value1, T value2) { throw null; }
public long AdvancePastAny(T value0, T value1, T value2, T value3) { throw null; }
public bool IsNext(System.ReadOnlySpan<T> next, bool advancePast = false) { throw null; }
public bool IsNext(T next, bool advancePast = false) { throw null; }
public void Rewind(long count) { }
public bool TryAdvanceTo(T delimiter, bool advancePastDelimiter = true) { throw null; }
public bool TryAdvanceToAny(System.ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true) { throw null; }
public readonly bool TryCopyTo(System.Span<T> destination) { throw null; }
public readonly bool TryPeek(out T value) { throw null; }
public readonly bool TryPeek(long offset, out T value) { throw null; }
public bool TryRead(out T value) { throw null; }
public bool TryReadTo(out System.Buffers.ReadOnlySequence<T> sequence, System.ReadOnlySpan<T> delimiter, bool advancePastDelimiter = true) { throw null; }
public bool TryReadTo(out System.Buffers.ReadOnlySequence<T> sequence, T delimiter, bool advancePastDelimiter = true) { throw null; }
public bool TryReadTo(out System.Buffers.ReadOnlySequence<T> sequence, T delimiter, T delimiterEscape, bool advancePastDelimiter = true) { throw null; }
public bool TryReadTo(out System.ReadOnlySpan<T> span, T delimiter, bool advancePastDelimiter = true) { throw null; }
public bool TryReadTo(out System.ReadOnlySpan<T> span, T delimiter, T delimiterEscape, bool advancePastDelimiter = true) { throw null; }
public bool TryReadToAny(out System.Buffers.ReadOnlySequence<T> sequence, System.ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true) { throw null; }
public bool TryReadToAny(out System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> delimiters, bool advancePastDelimiter = true) { throw null; }
}
public readonly partial struct StandardFormat : System.IEquatable<System.Buffers.StandardFormat>
{
private readonly int _dummyPrimitive;
public const byte MaxPrecision = (byte)99;
public const byte NoPrecision = (byte)255;
public StandardFormat(char symbol, byte precision = (byte)255) { throw null; }
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 bool Equals(System.Buffers.StandardFormat other) { throw null; }
public override bool Equals(object? obj) { throw null; }
public override int GetHashCode() { throw null; }
public static bool operator ==(System.Buffers.StandardFormat left, System.Buffers.StandardFormat right) { throw null; }
public static implicit operator System.Buffers.StandardFormat (char symbol) { throw null; }
public static bool operator !=(System.Buffers.StandardFormat left, System.Buffers.StandardFormat right) { throw null; }
public static System.Buffers.StandardFormat Parse(System.ReadOnlySpan<char> format) { throw null; }
public static System.Buffers.StandardFormat Parse(string? format) { throw null; }
public override string ToString() { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> format, out System.Buffers.StandardFormat result) { throw null; }
}
}
namespace System.Buffers.Binary
{
public static partial class BinaryPrimitives
{
public static short ReadInt16BigEndian(System.ReadOnlySpan<byte> source) { throw null; }
public static short ReadInt16LittleEndian(System.ReadOnlySpan<byte> source) { throw null; }
public static int ReadInt32BigEndian(System.ReadOnlySpan<byte> source) { throw null; }
public static int ReadInt32LittleEndian(System.ReadOnlySpan<byte> source) { throw null; }
public static long ReadInt64BigEndian(System.ReadOnlySpan<byte> source) { throw null; }
public static long ReadInt64LittleEndian(System.ReadOnlySpan<byte> source) { throw null; }
[System.CLSCompliantAttribute(false)]
public static ushort ReadUInt16BigEndian(System.ReadOnlySpan<byte> source) { throw null; }
[System.CLSCompliantAttribute(false)]
public static ushort ReadUInt16LittleEndian(System.ReadOnlySpan<byte> source) { throw null; }
[System.CLSCompliantAttribute(false)]
public static uint ReadUInt32BigEndian(System.ReadOnlySpan<byte> source) { throw null; }
[System.CLSCompliantAttribute(false)]
public static uint ReadUInt32LittleEndian(System.ReadOnlySpan<byte> source) { throw null; }
[System.CLSCompliantAttribute(false)]
public static ulong ReadUInt64BigEndian(System.ReadOnlySpan<byte> source) { throw null; }
[System.CLSCompliantAttribute(false)]
public static ulong ReadUInt64LittleEndian(System.ReadOnlySpan<byte> 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; }
[System.CLSCompliantAttribute(false)]
public static sbyte ReverseEndianness(sbyte value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static ushort ReverseEndianness(ushort value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static uint ReverseEndianness(uint value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static ulong ReverseEndianness(ulong value) { throw null; }
public static bool TryReadInt16BigEndian(System.ReadOnlySpan<byte> source, out short value) { throw null; }
public static bool TryReadInt16LittleEndian(System.ReadOnlySpan<byte> source, out short value) { throw null; }
public static bool TryReadInt32BigEndian(System.ReadOnlySpan<byte> source, out int value) { throw null; }
public static bool TryReadInt32LittleEndian(System.ReadOnlySpan<byte> source, out int value) { throw null; }
public static bool TryReadInt64BigEndian(System.ReadOnlySpan<byte> source, out long value) { throw null; }
public static bool TryReadInt64LittleEndian(System.ReadOnlySpan<byte> source, out long value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryReadUInt16BigEndian(System.ReadOnlySpan<byte> source, out ushort value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryReadUInt16LittleEndian(System.ReadOnlySpan<byte> source, out ushort value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryReadUInt32BigEndian(System.ReadOnlySpan<byte> source, out uint value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryReadUInt32LittleEndian(System.ReadOnlySpan<byte> source, out uint value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryReadUInt64BigEndian(System.ReadOnlySpan<byte> source, out ulong value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryReadUInt64LittleEndian(System.ReadOnlySpan<byte> source, out ulong value) { throw null; }
public static bool TryWriteInt16BigEndian(System.Span<byte> destination, short value) { throw null; }
public static bool TryWriteInt16LittleEndian(System.Span<byte> destination, short value) { throw null; }
public static bool TryWriteInt32BigEndian(System.Span<byte> destination, int value) { throw null; }
public static bool TryWriteInt32LittleEndian(System.Span<byte> destination, int value) { throw null; }
public static bool TryWriteInt64BigEndian(System.Span<byte> destination, long value) { throw null; }
public static bool TryWriteInt64LittleEndian(System.Span<byte> destination, long value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryWriteUInt16BigEndian(System.Span<byte> destination, ushort value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryWriteUInt16LittleEndian(System.Span<byte> destination, ushort value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryWriteUInt32BigEndian(System.Span<byte> destination, uint value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryWriteUInt32LittleEndian(System.Span<byte> destination, uint value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryWriteUInt64BigEndian(System.Span<byte> destination, ulong value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryWriteUInt64LittleEndian(System.Span<byte> destination, ulong value) { throw null; }
public static void WriteInt16BigEndian(System.Span<byte> destination, short value) { }
public static void WriteInt16LittleEndian(System.Span<byte> destination, short value) { }
public static void WriteInt32BigEndian(System.Span<byte> destination, int value) { }
public static void WriteInt32LittleEndian(System.Span<byte> destination, int value) { }
public static void WriteInt64BigEndian(System.Span<byte> destination, long value) { }
public static void WriteInt64LittleEndian(System.Span<byte> destination, long value) { }
[System.CLSCompliantAttribute(false)]
public static void WriteUInt16BigEndian(System.Span<byte> destination, ushort value) { }
[System.CLSCompliantAttribute(false)]
public static void WriteUInt16LittleEndian(System.Span<byte> destination, ushort value) { }
[System.CLSCompliantAttribute(false)]
public static void WriteUInt32BigEndian(System.Span<byte> destination, uint value) { }
[System.CLSCompliantAttribute(false)]
public static void WriteUInt32LittleEndian(System.Span<byte> destination, uint value) { }
[System.CLSCompliantAttribute(false)]
public static void WriteUInt64BigEndian(System.Span<byte> destination, ulong value) { }
[System.CLSCompliantAttribute(false)]
public static void WriteUInt64LittleEndian(System.Span<byte> destination, ulong value) { }
}
}
namespace System.Buffers.Text
{
public static partial class Base64
{
public static System.Buffers.OperationStatus DecodeFromUtf8(System.ReadOnlySpan<byte> utf8, System.Span<byte> bytes, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) { throw null; }
public static System.Buffers.OperationStatus DecodeFromUtf8InPlace(System.Span<byte> buffer, out int bytesWritten) { throw null; }
public static System.Buffers.OperationStatus EncodeToUtf8(System.ReadOnlySpan<byte> bytes, System.Span<byte> utf8, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) { throw null; }
public static System.Buffers.OperationStatus EncodeToUtf8InPlace(System.Span<byte> 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, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(byte value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(System.DateTime value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(System.DateTimeOffset value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(decimal value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(double value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(System.Guid value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(short value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(int value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(long value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryFormat(sbyte value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(float value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
public static bool TryFormat(System.TimeSpan value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryFormat(ushort value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryFormat(uint value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryFormat(ulong value, System.Span<byte> destination, out int bytesWritten, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { throw null; }
}
public static partial class Utf8Parser
{
public static bool TryParse(System.ReadOnlySpan<byte> source, out bool value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out byte value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out System.DateTime value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out System.DateTimeOffset value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out decimal value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out double value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out System.Guid value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out short value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out int value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out long value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryParse(System.ReadOnlySpan<byte> source, out sbyte value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out float value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
public static bool TryParse(System.ReadOnlySpan<byte> source, out System.TimeSpan value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryParse(System.ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryParse(System.ReadOnlySpan<byte> source, out uint value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryParse(System.ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed, char standardFormat = '\0') { throw null; }
}
}
namespace System.Runtime.InteropServices
{
public static partial class MemoryMarshal
{
public static System.ReadOnlySpan<byte> AsBytes<T>(System.ReadOnlySpan<T> span) where T : struct { throw null; }
public static System.Span<byte> AsBytes<T>(System.Span<T> span) where T : struct { throw null; }
public static System.Memory<T> AsMemory<T>(System.ReadOnlyMemory<T> memory) { throw null; }
public static ref readonly T AsRef<T>(System.ReadOnlySpan<byte> span) where T : struct { throw null; }
public static ref T AsRef<T>(System.Span<byte> span) where T : struct { throw null; }
public static System.ReadOnlySpan<TTo> Cast<TFrom, TTo>(System.ReadOnlySpan<TFrom> span) where TFrom : struct where TTo : struct { throw null; }
public static System.Span<TTo> Cast<TFrom, TTo>(System.Span<TFrom> span) where TFrom : struct where TTo : struct { throw null; }
public static System.Memory<T> CreateFromPinnedArray<T>(T[]? array, int start, int length) { throw null; }
public static System.ReadOnlySpan<T> CreateReadOnlySpan<T>(ref T reference, int length) { throw null; }
public static System.Span<T> CreateSpan<T>(ref T reference, int length) { throw null; }
public static ref T GetReference<T>(System.ReadOnlySpan<T> span) { throw null; }
public static ref T GetReference<T>(System.Span<T> span) { throw null; }
public static T Read<T>(System.ReadOnlySpan<byte> source) where T : struct { throw null; }
public static System.Collections.Generic.IEnumerable<T> ToEnumerable<T>(System.ReadOnlyMemory<T> memory) { throw null; }
public static bool TryGetArray<T>(System.ReadOnlyMemory<T> memory, out System.ArraySegment<T> segment) { throw null; }
public static bool TryGetMemoryManager<T, TManager>(System.ReadOnlyMemory<T> memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out TManager? manager) where TManager : System.Buffers.MemoryManager<T> { throw null; }
public static bool TryGetMemoryManager<T, TManager>(System.ReadOnlyMemory<T> memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out TManager? manager, out int start, out int length) where TManager : System.Buffers.MemoryManager<T> { throw null; }
public static bool TryGetString(System.ReadOnlyMemory<char> memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out string? text, out int start, out int length) { throw null; }
public static bool TryRead<T>(System.ReadOnlySpan<byte> source, out T value) where T : struct { throw null; }
public static bool TryWrite<T>(System.Span<byte> destination, ref T value) where T : struct { throw null; }
public static void Write<T>(System.Span<byte> destination, ref T value) where T : struct { }
}
public static partial class SequenceMarshal
{
public static bool TryGetArray<T>(System.Buffers.ReadOnlySequence<T> sequence, out System.ArraySegment<T> segment) { throw null; }
public static bool TryGetReadOnlyMemory<T>(System.Buffers.ReadOnlySequence<T> sequence, out System.ReadOnlyMemory<T> memory) { throw null; }
public static bool TryGetReadOnlySequenceSegment<T>(System.Buffers.ReadOnlySequence<T> sequence, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out System.Buffers.ReadOnlySequenceSegment<T>? startSegment, out int startIndex, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out System.Buffers.ReadOnlySequenceSegment<T>? endSegment, out int endIndex) { throw null; }
public static bool TryRead<T>(ref System.Buffers.SequenceReader<byte> reader, out T value) where T : unmanaged { throw null; }
}
}
namespace System.Text
{
public static partial class EncodingExtensions
{
public static void Convert(this System.Text.Decoder decoder, in System.Buffers.ReadOnlySequence<byte> bytes, System.Buffers.IBufferWriter<char> writer, bool flush, out long charsUsed, out bool completed) { throw null; }
public static void Convert(this System.Text.Decoder decoder, System.ReadOnlySpan<byte> bytes, System.Buffers.IBufferWriter<char> writer, bool flush, out long charsUsed, out bool completed) { throw null; }
public static void Convert(this System.Text.Encoder encoder, in System.Buffers.ReadOnlySequence<char> chars, System.Buffers.IBufferWriter<byte> writer, bool flush, out long bytesUsed, out bool completed) { throw null; }
public static void Convert(this System.Text.Encoder encoder, System.ReadOnlySpan<char> chars, System.Buffers.IBufferWriter<byte> writer, bool flush, out long bytesUsed, out bool completed) { throw null; }
public static byte[] GetBytes(this System.Text.Encoding encoding, in System.Buffers.ReadOnlySequence<char> chars) { throw null; }
public static long GetBytes(this System.Text.Encoding encoding, in System.Buffers.ReadOnlySequence<char> chars, System.Buffers.IBufferWriter<byte> writer) { throw null; }
public static int GetBytes(this System.Text.Encoding encoding, in System.Buffers.ReadOnlySequence<char> chars, System.Span<byte> bytes) { throw null; }
public static long GetBytes(this System.Text.Encoding encoding, System.ReadOnlySpan<char> chars, System.Buffers.IBufferWriter<byte> writer) { throw null; }
public static long GetChars(this System.Text.Encoding encoding, in System.Buffers.ReadOnlySequence<byte> bytes, System.Buffers.IBufferWriter<char> writer) { throw null; }
public static int GetChars(this System.Text.Encoding encoding, in System.Buffers.ReadOnlySequence<byte> bytes, System.Span<char> chars) { throw null; }
public static long GetChars(this System.Text.Encoding encoding, System.ReadOnlySpan<byte> bytes, System.Buffers.IBufferWriter<char> writer) { throw null; }
public static string GetString(this System.Text.Encoding encoding, in System.Buffers.ReadOnlySequence<byte> bytes) { throw null; }
}
public ref partial struct SpanRuneEnumerator
{
private object _dummy;
private int _dummyPrimitive;
public System.Text.Rune Current { get { throw null; } }
public System.Text.SpanRuneEnumerator GetEnumerator() { throw null; }
public bool MoveNext() { throw null; }
}
}
You can’t perform that action at this time.