@tsonic/dotnet 0.5.2 → 0.6.0

package/System.Buffers/internal/index.d.ts

@@ -50,25 +50,27 @@ export enum OperationStatus {
 
 
 export interface IBufferWriter_1$instance<T> {
-    Advance(count: int): void;
-    GetMemory(sizeHint?: int): Memory_1<T>;
-    GetSpan(sizeHint?: int): Span_1<T>;
+    advance(count: int): void;
+    getMemory(sizeHint?: int): Memory_1<T>;
+    getSpan(sizeHint?: int): Span_1<T>;
 }
 
 
 export type IBufferWriter_1<T> = IBufferWriter_1$instance<T>;
 
-export interface IMemoryOwner_1$instance<T> {
-    readonly Memory: Memory_1<T>;
-    Dispose(): void;
+export interface IMemoryOwner_1$instance<T> extends IDisposable {
+    readonly memory: Memory_1<T>;
+    dispose(): void;
 }
 
 
+export interface IMemoryOwner_1$instance<T> extends System_Internal.IDisposable$instance {}
+
 export type IMemoryOwner_1<T> = IMemoryOwner_1$instance<T>;
 
 export interface IPinnable$instance {
-    Pin(elementIndex: int): MemoryHandle;
-    Unpin(): void;
+    pin(elementIndex: int): MemoryHandle;
+    unpin(): void;
 }
 
 
@@ -82,9 +84,11 @@ export class MemoryHandle$instance {
 
 
 export interface __MemoryHandle$views {
-    readonly As_IDisposable: System_Internal.IDisposable$instance;
+    As_IDisposable(): System_Internal.IDisposable$instance;
 }
 
+export interface MemoryHandle$instance extends System_Internal.IDisposable$instance {}
+
 export type MemoryHandle = MemoryHandle$instance & __MemoryHandle$views;
 
 
@@ -173,25 +177,25 @@ export class SequenceReader_1$instance<T extends IEquatable_1<T>> {
 export type SequenceReader_1<T extends IEquatable_1<T>> = SequenceReader_1$instance<T>;
 
 export class StandardFormat$instance {
-    constructor(symbol_: string, precision: byte);
+    constructor(symbol_: char, precision: byte);
     readonly hasPrecision: boolean;
     readonly isDefault: boolean;
     readonly precision: byte;
-    readonly symbol_: string;
-    equals(obj: any): boolean;
+    readonly symbol_: char;
+    equals(obj: unknown): boolean;
     equals(other: StandardFormat): boolean;
     getHashCode(): int;
     toString(): string;
-    static readonly NoPrecision: byte;
-    static readonly MaxPrecision: byte;
-    static Parse(format: ReadOnlySpan_1<CLROf<string>>): StandardFormat;
-    static Parse(format: string): StandardFormat;
-    static TryParse(format: ReadOnlySpan_1<CLROf<string>>, result: { value: ref<StandardFormat> }): boolean;
+    static readonly noPrecision: byte;
+    static readonly maxPrecision: byte;
+    static parse(format: ReadOnlySpan_1<CLROf<char>>): StandardFormat;
+    static parse(format: string): StandardFormat;
+    static tryParse(format: ReadOnlySpan_1<CLROf<char>>, result: { value: ref<StandardFormat> }): boolean;
 }
 
 
 export interface __StandardFormat$views {
-    readonly As_IEquatable_1_of_ConsoleKeyInfo: System_Internal.IEquatable_1$instance<StandardFormat>;
+    As_IEquatable_1(): System_Internal.IEquatable_1$instance<StandardFormat>;
 
     // Structural method bridges for numeric interface constraints
     Equals(other: StandardFormat): boolean;
@@ -217,18 +221,20 @@ export class ArrayBufferWriter_1$instance<T> {
 
 
 export interface __ArrayBufferWriter_1$views<T> {
-    readonly As_IBufferWriter_1: IBufferWriter_1$instance<T>;
+    As_IBufferWriter_1(): IBufferWriter_1$instance<T>;
 }
 
+export interface ArrayBufferWriter_1$instance<T> extends IBufferWriter_1$instance<T> {}
+
 export type ArrayBufferWriter_1<T> = ArrayBufferWriter_1$instance<T> & __ArrayBufferWriter_1$views<T>;
 
 
 export abstract class ArrayPool_1$instance<T> {
     abstract rent(minimumLength: int): T[];
     abstract return_(array: T[], clearArray?: boolean): void;
-    static readonly Shared: unknown;
-    static Create<T>(): ArrayPool_1<T>;
-    static Create<T>(maxArrayLength: int, maxArraysPerBucket: int): ArrayPool_1<T>;
+    static readonly shared: unknown;
+    static create<T>(): ArrayPool_1<T>;
+    static create<T>(maxArrayLength: int, maxArraysPerBucket: int): ArrayPool_1<T>;
 }
 
 
@@ -243,11 +249,13 @@ export abstract class MemoryManager_1$instance<T> {
 
 
 export interface __MemoryManager_1$views<T> {
-    readonly As_IMemoryOwner_1: IMemoryOwner_1$instance<T>;
-    readonly As_IPinnable: IPinnable$instance;
-    readonly As_IDisposable: System_Internal.IDisposable$instance;
+    As_IMemoryOwner_1(): IMemoryOwner_1$instance<T>;
+    As_IPinnable(): IPinnable$instance;
+    As_IDisposable(): System_Internal.IDisposable$instance;
 }
 
+export interface MemoryManager_1$instance<T> extends IMemoryOwner_1$instance<T> {}
+
 export type MemoryManager_1<T> = MemoryManager_1$instance<T> & __MemoryManager_1$views<T>;
 
 
@@ -255,14 +263,16 @@ export abstract class MemoryPool_1$instance<T> {
     readonly maxBufferSize: int;
     dispose(): void;
     abstract rent(minBufferSize?: int): IMemoryOwner_1<T>;
-    static readonly Shared: unknown;
+    static readonly shared: unknown;
 }
 
 
 export interface __MemoryPool_1$views<T> {
-    readonly As_IDisposable: System_Internal.IDisposable$instance;
+    As_IDisposable(): System_Internal.IDisposable$instance;
 }
 
+export interface MemoryPool_1$instance<T> extends System_Internal.IDisposable$instance {}
+
 export type MemoryPool_1<T> = MemoryPool_1$instance<T> & __MemoryPool_1$views<T>;
 
 
@@ -276,9 +286,9 @@ export abstract class ReadOnlySequenceSegment_1$instance<T> {
 export type ReadOnlySequenceSegment_1<T> = ReadOnlySequenceSegment_1$instance<T>;
 
 export class ReadOnlySpanAction_2$instance<T, TArg> extends Function {
-    constructor(object_: any, method: nint);
-    beginInvoke(span: ReadOnlySpan_1<T>, arg: TArg, callback: AsyncCallback, object_: any): IAsyncResult;
-    clone(): any;
+    constructor(object_: unknown, method: nint);
+    beginInvoke(span: ReadOnlySpan_1<T>, arg: TArg, callback: AsyncCallback, object_: unknown): IAsyncResult;
+    clone(): unknown;
     endInvoke(result: IAsyncResult): void;
     getObjectData(info: SerializationInfo, context: StreamingContext): void;
     invoke(span: ReadOnlySpan_1<T>, arg: TArg): void;
@@ -286,8 +296,8 @@ export class ReadOnlySpanAction_2$instance<T, TArg> extends Function {
 
 
 export interface __ReadOnlySpanAction_2$views<T, TArg> {
-    readonly As_ICloneable: System_Internal.ICloneable$instance;
-    readonly As_ISerializable: System_Runtime_Serialization_Internal.ISerializable$instance;
+    As_ICloneable(): System_Internal.ICloneable$instance;
+    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
 }
 
 export type ReadOnlySpanAction_2<T, TArg> = ReadOnlySpanAction_2$instance<T, TArg> & __ReadOnlySpanAction_2$views<T, TArg>;
@@ -301,9 +311,9 @@ export class SearchValues_1$instance<T extends IEquatable_1<T>> {
 export type SearchValues_1<T extends IEquatable_1<T>> = SearchValues_1$instance<T>;
 
 export class SpanAction_2$instance<T, TArg> extends Function {
-    constructor(object_: any, method: nint);
-    beginInvoke(span: Span_1<T>, arg: TArg, callback: AsyncCallback, object_: any): IAsyncResult;
-    clone(): any;
+    constructor(object_: unknown, method: nint);
+    beginInvoke(span: Span_1<T>, arg: TArg, callback: AsyncCallback, object_: unknown): IAsyncResult;
+    clone(): unknown;
     endInvoke(result: IAsyncResult): void;
     getObjectData(info: SerializationInfo, context: StreamingContext): void;
     invoke(span: Span_1<T>, arg: TArg): void;
@@ -311,39 +321,39 @@ export class SpanAction_2$instance<T, TArg> extends Function {
 
 
 export interface __SpanAction_2$views<T, TArg> {
-    readonly As_ICloneable: System_Internal.ICloneable$instance;
-    readonly As_ISerializable: System_Runtime_Serialization_Internal.ISerializable$instance;
+    As_ICloneable(): System_Internal.ICloneable$instance;
+    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
 }
 
 export type SpanAction_2<T, TArg> = SpanAction_2$instance<T, TArg> & __SpanAction_2$views<T, TArg>;
 
 
 export abstract class BuffersExtensions$instance {
-    static CopyTo<T>(source: { value: ref<ReadOnlySequence_1<T>> }, destination: Span_1<T>): void;
-    static PositionOf<T extends IEquatable_1<T>>(source: { value: ref<ReadOnlySequence_1<T>> }, value: T): Nullable_1<SequencePosition>;
-    static ToArray<T>(sequence: { value: ref<ReadOnlySequence_1<T>> }): T[];
-    static Write<T>(writer: IBufferWriter_1<T>, value: ReadOnlySpan_1<T>): void;
+    static copyTo<T>(source: { value: ref<ReadOnlySequence_1<T>> }, destination: Span_1<T>): void;
+    static positionOf<T extends IEquatable_1<T>>(source: { value: ref<ReadOnlySequence_1<T>> }, value: T): Nullable_1<SequencePosition>;
+    static toArray<T>(sequence: { value: ref<ReadOnlySequence_1<T>> }): T[];
+    static write<T>(writer: IBufferWriter_1<T>, value: ReadOnlySpan_1<T>): void;
 }
 
 
 export type BuffersExtensions = BuffersExtensions$instance;
 
 export abstract class SearchValues$instance {
-    static Create(values: ReadOnlySpan_1<CLROf<byte>>): SearchValues_1<CLROf<byte>>;
-    static Create(values: ReadOnlySpan_1<CLROf<string>>): SearchValues_1<CLROf<string>>;
-    static Create(values: ReadOnlySpan_1<CLROf<string>>, comparisonType: StringComparison): SearchValues_1<CLROf<string>>;
+    static create(values: ReadOnlySpan_1<CLROf<byte>>): SearchValues_1<CLROf<byte>>;
+    static create(values: ReadOnlySpan_1<CLROf<char>>): SearchValues_1<CLROf<char>>;
+    static create(values: ReadOnlySpan_1<CLROf<string>>, comparisonType: StringComparison): SearchValues_1<CLROf<string>>;
 }
 
 
 export type SearchValues = SearchValues$instance;
 
 export abstract class SequenceReaderExtensions$instance {
-    static TryReadBigEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<short> }): boolean;
-    static TryReadBigEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<int> }): boolean;
-    static TryReadBigEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<long> }): boolean;
-    static TryReadLittleEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<short> }): boolean;
-    static TryReadLittleEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<int> }): boolean;
-    static TryReadLittleEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<long> }): boolean;
+    static tryReadBigEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<short> }): boolean;
+    static tryReadBigEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<int> }): boolean;
+    static tryReadBigEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<long> }): boolean;
+    static tryReadLittleEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<short> }): boolean;
+    static tryReadLittleEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<int> }): boolean;
+    static tryReadLittleEndian(reader: { value: ref<SequenceReader_1<CLROf<byte>>> }, value: { value: ref<long> }): boolean;
 }
 
 

package/System.Buffers.Binary/internal/index.d.ts

@@ -38,132 +38,132 @@ export type CLROf<T> =
     T; // Identity fallback for non-primitive types
 
 export abstract class BinaryPrimitives$instance {
-    static ReadDoubleBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): double;
-    static ReadDoubleLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): double;
-    static ReadHalfBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): half;
-    static ReadHalfLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): half;
-    static ReadInt128BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): int128;
-    static ReadInt128LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): int128;
-    static ReadInt16BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): short;
-    static ReadInt16LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): short;
-    static ReadInt32BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): int;
-    static ReadInt32LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): int;
-    static ReadInt64BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): long;
-    static ReadInt64LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): long;
-    static ReadIntPtrBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): nint;
-    static ReadIntPtrLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): nint;
-    static ReadSingleBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): float;
-    static ReadSingleLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): float;
-    static ReadUInt128BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): uint128;
-    static ReadUInt128LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): uint128;
-    static ReadUInt16BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): ushort;
-    static ReadUInt16LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): ushort;
-    static ReadUInt32BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): uint;
-    static ReadUInt32LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): uint;
-    static ReadUInt64BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): ulong;
-    static ReadUInt64LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): ulong;
-    static ReadUIntPtrBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): nuint;
-    static ReadUIntPtrLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): nuint;
-    static ReverseEndianness(value: byte): byte;
-    static ReverseEndianness(value: int128): int128;
-    static ReverseEndianness(value: short): short;
-    static ReverseEndianness(value: int): int;
-    static ReverseEndianness(value: long): long;
-    static ReverseEndianness(value: nint): nint;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<int128>>, destination: Span_1<CLROf<int128>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<short>>, destination: Span_1<CLROf<short>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<int>>, destination: Span_1<CLROf<int>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<long>>, destination: Span_1<CLROf<long>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<nint>>, destination: Span_1<CLROf<nint>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<uint128>>, destination: Span_1<CLROf<uint128>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<ushort>>, destination: Span_1<CLROf<ushort>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<uint>>, destination: Span_1<CLROf<uint>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<ulong>>, destination: Span_1<CLROf<ulong>>): void;
-    static ReverseEndianness(source: ReadOnlySpan_1<CLROf<nuint>>, destination: Span_1<CLROf<nuint>>): void;
-    static ReverseEndianness(value: sbyte): sbyte;
-    static ReverseEndianness(value: uint128): uint128;
-    static ReverseEndianness(value: ushort): ushort;
-    static ReverseEndianness(value: uint): uint;
-    static ReverseEndianness(value: ulong): ulong;
-    static ReverseEndianness(value: nuint): nuint;
-    static TryReadDoubleBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<double> }): boolean;
-    static TryReadDoubleLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<double> }): boolean;
-    static TryReadHalfBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<half> }): boolean;
-    static TryReadHalfLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<half> }): boolean;
-    static TryReadInt128BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<int128> }): boolean;
-    static TryReadInt128LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<int128> }): boolean;
-    static TryReadInt16BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<short> }): boolean;
-    static TryReadInt16LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<short> }): boolean;
-    static TryReadInt32BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<int> }): boolean;
-    static TryReadInt32LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<int> }): boolean;
-    static TryReadInt64BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<long> }): boolean;
-    static TryReadInt64LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<long> }): boolean;
-    static TryReadIntPtrBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<nint> }): boolean;
-    static TryReadIntPtrLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<nint> }): boolean;
-    static TryReadSingleBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<float> }): boolean;
-    static TryReadSingleLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<float> }): boolean;
-    static TryReadUInt128BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<uint128> }): boolean;
-    static TryReadUInt128LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<uint128> }): boolean;
-    static TryReadUInt16BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<ushort> }): boolean;
-    static TryReadUInt16LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<ushort> }): boolean;
-    static TryReadUInt32BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<uint> }): boolean;
-    static TryReadUInt32LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<uint> }): boolean;
-    static TryReadUInt64BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<ulong> }): boolean;
-    static TryReadUInt64LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<ulong> }): boolean;
-    static TryReadUIntPtrBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<nuint> }): boolean;
-    static TryReadUIntPtrLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<nuint> }): boolean;
-    static TryWriteDoubleBigEndian(destination: Span_1<CLROf<byte>>, value: double): boolean;
-    static TryWriteDoubleLittleEndian(destination: Span_1<CLROf<byte>>, value: double): boolean;
-    static TryWriteHalfBigEndian(destination: Span_1<CLROf<byte>>, value: half): boolean;
-    static TryWriteHalfLittleEndian(destination: Span_1<CLROf<byte>>, value: half): boolean;
-    static TryWriteInt128BigEndian(destination: Span_1<CLROf<byte>>, value: int128): boolean;
-    static TryWriteInt128LittleEndian(destination: Span_1<CLROf<byte>>, value: int128): boolean;
-    static TryWriteInt16BigEndian(destination: Span_1<CLROf<byte>>, value: short): boolean;
-    static TryWriteInt16LittleEndian(destination: Span_1<CLROf<byte>>, value: short): boolean;
-    static TryWriteInt32BigEndian(destination: Span_1<CLROf<byte>>, value: int): boolean;
-    static TryWriteInt32LittleEndian(destination: Span_1<CLROf<byte>>, value: int): boolean;
-    static TryWriteInt64BigEndian(destination: Span_1<CLROf<byte>>, value: long): boolean;
-    static TryWriteInt64LittleEndian(destination: Span_1<CLROf<byte>>, value: long): boolean;
-    static TryWriteIntPtrBigEndian(destination: Span_1<CLROf<byte>>, value: nint): boolean;
-    static TryWriteIntPtrLittleEndian(destination: Span_1<CLROf<byte>>, value: nint): boolean;
-    static TryWriteSingleBigEndian(destination: Span_1<CLROf<byte>>, value: float): boolean;
-    static TryWriteSingleLittleEndian(destination: Span_1<CLROf<byte>>, value: float): boolean;
-    static TryWriteUInt128BigEndian(destination: Span_1<CLROf<byte>>, value: uint128): boolean;
-    static TryWriteUInt128LittleEndian(destination: Span_1<CLROf<byte>>, value: uint128): boolean;
-    static TryWriteUInt16BigEndian(destination: Span_1<CLROf<byte>>, value: ushort): boolean;
-    static TryWriteUInt16LittleEndian(destination: Span_1<CLROf<byte>>, value: ushort): boolean;
-    static TryWriteUInt32BigEndian(destination: Span_1<CLROf<byte>>, value: uint): boolean;
-    static TryWriteUInt32LittleEndian(destination: Span_1<CLROf<byte>>, value: uint): boolean;
-    static TryWriteUInt64BigEndian(destination: Span_1<CLROf<byte>>, value: ulong): boolean;
-    static TryWriteUInt64LittleEndian(destination: Span_1<CLROf<byte>>, value: ulong): boolean;
-    static TryWriteUIntPtrBigEndian(destination: Span_1<CLROf<byte>>, value: nuint): boolean;
-    static TryWriteUIntPtrLittleEndian(destination: Span_1<CLROf<byte>>, value: nuint): boolean;
-    static WriteDoubleBigEndian(destination: Span_1<CLROf<byte>>, value: double): void;
-    static WriteDoubleLittleEndian(destination: Span_1<CLROf<byte>>, value: double): void;
-    static WriteHalfBigEndian(destination: Span_1<CLROf<byte>>, value: half): void;
-    static WriteHalfLittleEndian(destination: Span_1<CLROf<byte>>, value: half): void;
-    static WriteInt128BigEndian(destination: Span_1<CLROf<byte>>, value: int128): void;
-    static WriteInt128LittleEndian(destination: Span_1<CLROf<byte>>, value: int128): void;
-    static WriteInt16BigEndian(destination: Span_1<CLROf<byte>>, value: short): void;
-    static WriteInt16LittleEndian(destination: Span_1<CLROf<byte>>, value: short): void;
-    static WriteInt32BigEndian(destination: Span_1<CLROf<byte>>, value: int): void;
-    static WriteInt32LittleEndian(destination: Span_1<CLROf<byte>>, value: int): void;
-    static WriteInt64BigEndian(destination: Span_1<CLROf<byte>>, value: long): void;
-    static WriteInt64LittleEndian(destination: Span_1<CLROf<byte>>, value: long): void;
-    static WriteIntPtrBigEndian(destination: Span_1<CLROf<byte>>, value: nint): void;
-    static WriteIntPtrLittleEndian(destination: Span_1<CLROf<byte>>, value: nint): void;
-    static WriteSingleBigEndian(destination: Span_1<CLROf<byte>>, value: float): void;
-    static WriteSingleLittleEndian(destination: Span_1<CLROf<byte>>, value: float): void;
-    static WriteUInt128BigEndian(destination: Span_1<CLROf<byte>>, value: uint128): void;
-    static WriteUInt128LittleEndian(destination: Span_1<CLROf<byte>>, value: uint128): void;
-    static WriteUInt16BigEndian(destination: Span_1<CLROf<byte>>, value: ushort): void;
-    static WriteUInt16LittleEndian(destination: Span_1<CLROf<byte>>, value: ushort): void;
-    static WriteUInt32BigEndian(destination: Span_1<CLROf<byte>>, value: uint): void;
-    static WriteUInt32LittleEndian(destination: Span_1<CLROf<byte>>, value: uint): void;
-    static WriteUInt64BigEndian(destination: Span_1<CLROf<byte>>, value: ulong): void;
-    static WriteUInt64LittleEndian(destination: Span_1<CLROf<byte>>, value: ulong): void;
-    static WriteUIntPtrBigEndian(destination: Span_1<CLROf<byte>>, value: nuint): void;
-    static WriteUIntPtrLittleEndian(destination: Span_1<CLROf<byte>>, value: nuint): void;
+    static readDoubleBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): double;
+    static readDoubleLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): double;
+    static readHalfBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): half;
+    static readHalfLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): half;
+    static readInt128BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): int128;
+    static readInt128LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): int128;
+    static readInt16BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): short;
+    static readInt16LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): short;
+    static readInt32BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): int;
+    static readInt32LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): int;
+    static readInt64BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): long;
+    static readInt64LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): long;
+    static readIntPtrBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): nint;
+    static readIntPtrLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): nint;
+    static readSingleBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): float;
+    static readSingleLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): float;
+    static readUInt128BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): uint128;
+    static readUInt128LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): uint128;
+    static readUInt16BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): ushort;
+    static readUInt16LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): ushort;
+    static readUInt32BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): uint;
+    static readUInt32LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): uint;
+    static readUInt64BigEndian(source: ReadOnlySpan_1<CLROf<byte>>): ulong;
+    static readUInt64LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): ulong;
+    static readUIntPtrBigEndian(source: ReadOnlySpan_1<CLROf<byte>>): nuint;
+    static readUIntPtrLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>): nuint;
+    static reverseEndianness7(value: byte): byte;
+    static reverseEndianness7(value: int128): int128;
+    static reverseEndianness7(value: short): short;
+    static reverseEndianness7(value: int): int;
+    static reverseEndianness7(value: long): long;
+    static reverseEndianness7(value: nint): nint;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<int128>>, destination: Span_1<CLROf<int128>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<short>>, destination: Span_1<CLROf<short>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<int>>, destination: Span_1<CLROf<int>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<long>>, destination: Span_1<CLROf<long>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<nint>>, destination: Span_1<CLROf<nint>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<uint128>>, destination: Span_1<CLROf<uint128>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<ushort>>, destination: Span_1<CLROf<ushort>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<uint>>, destination: Span_1<CLROf<uint>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<ulong>>, destination: Span_1<CLROf<ulong>>): void;
+    static reverseEndianness7(source: ReadOnlySpan_1<CLROf<nuint>>, destination: Span_1<CLROf<nuint>>): void;
+    static reverseEndianness7(value: sbyte): sbyte;
+    static reverseEndianness7(value: uint128): uint128;
+    static reverseEndianness7(value: ushort): ushort;
+    static reverseEndianness7(value: uint): uint;
+    static reverseEndianness7(value: ulong): ulong;
+    static reverseEndianness7(value: nuint): nuint;
+    static tryReadDoubleBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<double> }): boolean;
+    static tryReadDoubleLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<double> }): boolean;
+    static tryReadHalfBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<half> }): boolean;
+    static tryReadHalfLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<half> }): boolean;
+    static tryReadInt128BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<int128> }): boolean;
+    static tryReadInt128LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<int128> }): boolean;
+    static tryReadInt16BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<short> }): boolean;
+    static tryReadInt16LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<short> }): boolean;
+    static tryReadInt32BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<int> }): boolean;
+    static tryReadInt32LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<int> }): boolean;
+    static tryReadInt64BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<long> }): boolean;
+    static tryReadInt64LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<long> }): boolean;
+    static tryReadIntPtrBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<nint> }): boolean;
+    static tryReadIntPtrLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<nint> }): boolean;
+    static tryReadSingleBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<float> }): boolean;
+    static tryReadSingleLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<float> }): boolean;
+    static tryReadUInt128BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<uint128> }): boolean;
+    static tryReadUInt128LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<uint128> }): boolean;
+    static tryReadUInt16BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<ushort> }): boolean;
+    static tryReadUInt16LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<ushort> }): boolean;
+    static tryReadUInt32BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<uint> }): boolean;
+    static tryReadUInt32LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<uint> }): boolean;
+    static tryReadUInt64BigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<ulong> }): boolean;
+    static tryReadUInt64LittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<ulong> }): boolean;
+    static tryReadUIntPtrBigEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<nuint> }): boolean;
+    static tryReadUIntPtrLittleEndian(source: ReadOnlySpan_1<CLROf<byte>>, value: { value: ref<nuint> }): boolean;
+    static tryWriteDoubleBigEndian(destination: Span_1<CLROf<byte>>, value: double): boolean;
+    static tryWriteDoubleLittleEndian(destination: Span_1<CLROf<byte>>, value: double): boolean;
+    static tryWriteHalfBigEndian(destination: Span_1<CLROf<byte>>, value: half): boolean;
+    static tryWriteHalfLittleEndian(destination: Span_1<CLROf<byte>>, value: half): boolean;
+    static tryWriteInt128BigEndian(destination: Span_1<CLROf<byte>>, value: int128): boolean;
+    static tryWriteInt128LittleEndian(destination: Span_1<CLROf<byte>>, value: int128): boolean;
+    static tryWriteInt16BigEndian(destination: Span_1<CLROf<byte>>, value: short): boolean;
+    static tryWriteInt16LittleEndian(destination: Span_1<CLROf<byte>>, value: short): boolean;
+    static tryWriteInt32BigEndian(destination: Span_1<CLROf<byte>>, value: int): boolean;
+    static tryWriteInt32LittleEndian(destination: Span_1<CLROf<byte>>, value: int): boolean;
+    static tryWriteInt64BigEndian(destination: Span_1<CLROf<byte>>, value: long): boolean;
+    static tryWriteInt64LittleEndian(destination: Span_1<CLROf<byte>>, value: long): boolean;
+    static tryWriteIntPtrBigEndian(destination: Span_1<CLROf<byte>>, value: nint): boolean;
+    static tryWriteIntPtrLittleEndian(destination: Span_1<CLROf<byte>>, value: nint): boolean;
+    static tryWriteSingleBigEndian(destination: Span_1<CLROf<byte>>, value: float): boolean;
+    static tryWriteSingleLittleEndian(destination: Span_1<CLROf<byte>>, value: float): boolean;
+    static tryWriteUInt128BigEndian(destination: Span_1<CLROf<byte>>, value: uint128): boolean;
+    static tryWriteUInt128LittleEndian(destination: Span_1<CLROf<byte>>, value: uint128): boolean;
+    static tryWriteUInt16BigEndian(destination: Span_1<CLROf<byte>>, value: ushort): boolean;
+    static tryWriteUInt16LittleEndian(destination: Span_1<CLROf<byte>>, value: ushort): boolean;
+    static tryWriteUInt32BigEndian(destination: Span_1<CLROf<byte>>, value: uint): boolean;
+    static tryWriteUInt32LittleEndian(destination: Span_1<CLROf<byte>>, value: uint): boolean;
+    static tryWriteUInt64BigEndian(destination: Span_1<CLROf<byte>>, value: ulong): boolean;
+    static tryWriteUInt64LittleEndian(destination: Span_1<CLROf<byte>>, value: ulong): boolean;
+    static tryWriteUIntPtrBigEndian(destination: Span_1<CLROf<byte>>, value: nuint): boolean;
+    static tryWriteUIntPtrLittleEndian(destination: Span_1<CLROf<byte>>, value: nuint): boolean;
+    static writeDoubleBigEndian(destination: Span_1<CLROf<byte>>, value: double): void;
+    static writeDoubleLittleEndian(destination: Span_1<CLROf<byte>>, value: double): void;
+    static writeHalfBigEndian(destination: Span_1<CLROf<byte>>, value: half): void;
+    static writeHalfLittleEndian(destination: Span_1<CLROf<byte>>, value: half): void;
+    static writeInt128BigEndian(destination: Span_1<CLROf<byte>>, value: int128): void;
+    static writeInt128LittleEndian(destination: Span_1<CLROf<byte>>, value: int128): void;
+    static writeInt16BigEndian(destination: Span_1<CLROf<byte>>, value: short): void;
+    static writeInt16LittleEndian(destination: Span_1<CLROf<byte>>, value: short): void;
+    static writeInt32BigEndian(destination: Span_1<CLROf<byte>>, value: int): void;
+    static writeInt32LittleEndian(destination: Span_1<CLROf<byte>>, value: int): void;
+    static writeInt64BigEndian(destination: Span_1<CLROf<byte>>, value: long): void;
+    static writeInt64LittleEndian(destination: Span_1<CLROf<byte>>, value: long): void;
+    static writeIntPtrBigEndian(destination: Span_1<CLROf<byte>>, value: nint): void;
+    static writeIntPtrLittleEndian(destination: Span_1<CLROf<byte>>, value: nint): void;
+    static writeSingleBigEndian(destination: Span_1<CLROf<byte>>, value: float): void;
+    static writeSingleLittleEndian(destination: Span_1<CLROf<byte>>, value: float): void;
+    static writeUInt128BigEndian(destination: Span_1<CLROf<byte>>, value: uint128): void;
+    static writeUInt128LittleEndian(destination: Span_1<CLROf<byte>>, value: uint128): void;
+    static writeUInt16BigEndian(destination: Span_1<CLROf<byte>>, value: ushort): void;
+    static writeUInt16LittleEndian(destination: Span_1<CLROf<byte>>, value: ushort): void;
+    static writeUInt32BigEndian(destination: Span_1<CLROf<byte>>, value: uint): void;
+    static writeUInt32LittleEndian(destination: Span_1<CLROf<byte>>, value: uint): void;
+    static writeUInt64BigEndian(destination: Span_1<CLROf<byte>>, value: ulong): void;
+    static writeUInt64LittleEndian(destination: Span_1<CLROf<byte>>, value: ulong): void;
+    static writeUIntPtrBigEndian(destination: Span_1<CLROf<byte>>, value: nuint): void;
+    static writeUIntPtrLittleEndian(destination: Span_1<CLROf<byte>>, value: nuint): void;
 }