@tsonic/dotnet-pure/System.Net.Quic/internal/index.d.ts

TypeScript type definitions for .NET 10 BCL (Base Class Library) - CLR naming

// Generated by tsbindgen - Architecture
// Namespace: System.Net.Quic
// Assembly: System.Net.Quic

// Branded primitive types are sourced from @tsonic/types
import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/types';

// Import types from other namespaces
import type { List_1 } from "../../System.Collections.Generic/internal/index.js";
import type { IDictionary } from "../../System.Collections/internal/index.js";
import * as System_IO_Internal from "../../System.IO/internal/index.js";
import type { IOException, SeekOrigin, Stream } from "../../System.IO/internal/index.js";
import type { SslApplicationProtocol, SslClientAuthenticationOptions, SslClientHelloInfo, SslServerAuthenticationOptions, TlsCipherSuite } from "../../System.Net.Security/internal/index.js";
import type { EndPoint, IPEndPoint } from "../../System.Net/internal/index.js";
import type { MethodBase } from "../../System.Reflection/internal/index.js";
import * as System_Runtime_Serialization_Internal from "../../System.Runtime.Serialization/internal/index.js";
import type { ISerializable, SerializationInfo, StreamingContext } from "../../System.Runtime.Serialization/internal/index.js";
import type { SslProtocols } from "../../System.Security.Authentication/internal/index.js";
import type { X509Certificate } from "../../System.Security.Cryptography.X509Certificates/internal/index.js";
import type { Task, Task_1, ValueTask, ValueTask_1 } from "../../System.Threading.Tasks/internal/index.js";
import type { CancellationToken } from "../../System.Threading/internal/index.js";
import * as System_Internal from "../../System/internal/index.js";
import type { Action_2, AsyncCallback, Boolean as ClrBoolean, Byte, Enum, Exception, Func_4, IAsyncDisposable, IAsyncResult, IComparable, IConvertible, IDisposable, IFormatProvider, IFormattable, Int32, Int64, ISpanFormattable, Memory_1, Nullable_1, Object as ClrObject, ReadOnlyMemory_1, ReadOnlySpan_1, Span_1, String as ClrString, TimeSpan, Type, TypeCode, ValueType, Void } from "../../System/internal/index.js";

// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
// Value positions (parameters, return types) use lowercase primitives for ergonomics
export type CLROf<T> =
    T extends sbyte ? System_Internal.SByte :
    T extends short ? System_Internal.Int16 :
    T extends int ? System_Internal.Int32 :
    T extends long ? System_Internal.Int64 :
    T extends int128 ? System_Internal.Int128 :
    T extends nint ? System_Internal.IntPtr :
    T extends byte ? System_Internal.Byte :
    T extends ushort ? System_Internal.UInt16 :
    T extends uint ? System_Internal.UInt32 :
    T extends ulong ? System_Internal.UInt64 :
    T extends uint128 ? System_Internal.UInt128 :
    T extends nuint ? System_Internal.UIntPtr :
    T extends half ? System_Internal.Half :
    T extends float ? System_Internal.Single :
    T extends double ? System_Internal.Double :
    T extends decimal ? System_Internal.Decimal :
    T extends char ? System_Internal.Char :
    T extends boolean ? System_Internal.Boolean :
    T extends string ? System_Internal.String :
    T; // Identity fallback for non-primitive types

export enum QuicAbortDirection {
    Read = 1,
    Write = 2,
    Both = 3
}


export enum QuicError {
    Success = 0,
    InternalError = 1,
    ConnectionAborted = 2,
    StreamAborted = 3,
    ConnectionTimeout = 6,
    ConnectionRefused = 8,
    VersionNegotiationError = 9,
    ConnectionIdle = 10,
    OperationAborted = 12,
    AlpnInUse = 13,
    TransportError = 14,
    CallbackError = 15
}


export enum QuicStreamType {
    Unidirectional = 0,
    Bidirectional = 1
}


export interface QuicStreamCapacityChangedArgs$instance {
    BidirectionalIncrement: int;
    UnidirectionalIncrement: int;
}


export const QuicStreamCapacityChangedArgs: {
    new(): QuicStreamCapacityChangedArgs$instance;
};


export type QuicStreamCapacityChangedArgs = QuicStreamCapacityChangedArgs$instance;

export interface QuicClientConnectionOptions$instance extends QuicConnectionOptions {
    ClientAuthenticationOptions: SslClientAuthenticationOptions;
    LocalEndPoint: IPEndPoint;
    RemoteEndPoint: EndPoint;
}


export const QuicClientConnectionOptions: {
    new(): QuicClientConnectionOptions$instance;
};


export type QuicClientConnectionOptions = QuicClientConnectionOptions$instance;

export interface QuicConnection$instance {
    readonly LocalEndPoint: IPEndPoint;
    readonly NegotiatedApplicationProtocol: SslApplicationProtocol;
    readonly NegotiatedCipherSuite: TlsCipherSuite;
    readonly RemoteCertificate: X509Certificate;
    readonly RemoteEndPoint: IPEndPoint;
    readonly SslProtocol: SslProtocols;
    readonly TargetHostName: string;
    AcceptInboundStreamAsync(cancellationToken?: CancellationToken): ValueTask_1<QuicStream>;
    CloseAsync(errorCode: long, cancellationToken?: CancellationToken): ValueTask;
    DisposeAsync(): ValueTask;
    OpenOutboundStreamAsync(type_: QuicStreamType, cancellationToken?: CancellationToken): ValueTask_1<QuicStream>;
    ToString(): string;
}


export const QuicConnection: {
    new(): QuicConnection$instance;
    readonly IsSupported: boolean;
    ConnectAsync(options: QuicClientConnectionOptions, cancellationToken?: CancellationToken): ValueTask_1<QuicConnection>;
};


export interface __QuicConnection$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
}

export interface QuicConnection$instance extends System_Internal.IAsyncDisposable$instance {}

export type QuicConnection = QuicConnection$instance & __QuicConnection$views;


export interface QuicConnectionOptions$instance {
    DefaultCloseErrorCode: long;
    DefaultStreamErrorCode: long;
    HandshakeTimeout: TimeSpan;
    IdleTimeout: TimeSpan;
    InitialReceiveWindowSizes: QuicReceiveWindowSizes;
    KeepAliveInterval: TimeSpan;
    MaxInboundBidirectionalStreams: int;
    MaxInboundUnidirectionalStreams: int;
    StreamCapacityCallback: Action_2<QuicConnection, QuicStreamCapacityChangedArgs>;
}


export const QuicConnectionOptions: {
};


export type QuicConnectionOptions = QuicConnectionOptions$instance;

export interface QuicException$instance extends IOException {
    readonly ApplicationErrorCode: Nullable_1<CLROf<long>>;
    readonly QuicError: QuicError;
    readonly TransportErrorCode: Nullable_1<CLROf<long>>;
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const QuicException: {
    new(error: QuicError, applicationErrorCode: Nullable_1<CLROf<long>>, message: string): QuicException$instance;
};


export interface __QuicException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type QuicException = QuicException$instance & __QuicException$views;


export interface QuicListener$instance {
    readonly LocalEndPoint: IPEndPoint;
    AcceptConnectionAsync(cancellationToken?: CancellationToken): ValueTask_1<QuicConnection>;
    DisposeAsync(): ValueTask;
    ToString(): string;
}


export const QuicListener: {
    new(): QuicListener$instance;
    readonly IsSupported: boolean;
    ListenAsync(options: QuicListenerOptions, cancellationToken?: CancellationToken): ValueTask_1<QuicListener>;
};


export interface __QuicListener$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
}

export interface QuicListener$instance extends System_Internal.IAsyncDisposable$instance {}

export type QuicListener = QuicListener$instance & __QuicListener$views;


export interface QuicListenerOptions$instance {
    ApplicationProtocols: List_1<SslApplicationProtocol>;
    ConnectionOptionsCallback: Func_4<QuicConnection, SslClientHelloInfo, CancellationToken, ValueTask_1<QuicServerConnectionOptions>>;
    ListenBacklog: int;
    ListenEndPoint: IPEndPoint;
}


export const QuicListenerOptions: {
    new(): QuicListenerOptions$instance;
};


export type QuicListenerOptions = QuicListenerOptions$instance;

export interface QuicReceiveWindowSizes$instance {
    Connection: int;
    LocallyInitiatedBidirectionalStream: int;
    RemotelyInitiatedBidirectionalStream: int;
    UnidirectionalStream: int;
}


export const QuicReceiveWindowSizes: {
    new(): QuicReceiveWindowSizes$instance;
};


export type QuicReceiveWindowSizes = QuicReceiveWindowSizes$instance;

export interface QuicServerConnectionOptions$instance extends QuicConnectionOptions {
    ServerAuthenticationOptions: SslServerAuthenticationOptions;
}


export const QuicServerConnectionOptions: {
    new(): QuicServerConnectionOptions$instance;
};


export type QuicServerConnectionOptions = QuicServerConnectionOptions$instance;

export interface QuicStream$instance extends Stream {
    readonly CanRead: boolean;
    readonly CanSeek: boolean;
    readonly CanTimeout: boolean;
    readonly CanWrite: boolean;
    readonly Id: long;
    readonly Length: long;
    Position: long;
    readonly ReadsClosed: Task;
    ReadTimeout: int;
    readonly Type: QuicStreamType;
    readonly WritesClosed: Task;
    WriteTimeout: int;
    Abort(abortDirection: QuicAbortDirection, errorCode: long): void;
    BeginRead(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    BeginWrite(buffer: byte[], offset: int, count: int, callback: AsyncCallback, state: unknown): IAsyncResult;
    CompleteWrites(): void;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    EndRead(asyncResult: IAsyncResult): int;
    EndWrite(asyncResult: IAsyncResult): void;
    Flush(): void;
    FlushAsync(cancellationToken?: CancellationToken): Task;
    FlushAsync(): Task;
    Read(buffer: byte[], offset: int, count: int): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    Read(buffer: Span_1<CLROf<byte>>): int;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken?: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int): Task_1<CLROf<int>>;
    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<CLROf<int>>;
    ReadAsync(buffer: Memory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask_1<CLROf<int>>;
    ReadByte(): int;
    Seek(offset: long, origin: SeekOrigin): long;
    SetLength(value: long): void;
    ToString(): string;
    Write(buffer: byte[], offset: int, count: int): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    Write(buffer: ReadOnlySpan_1<CLROf<byte>>): void;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteAsync(buffer: byte[], offset: int, count: int, cancellationToken?: CancellationToken): Task;
    WriteAsync(buffer: byte[], offset: int, count: int): Task;
    WriteAsync(buffer: ReadOnlyMemory_1<CLROf<byte>>, cancellationToken?: CancellationToken): ValueTask;
    WriteByte(value: byte): void;
}


export const QuicStream: {
    new(): QuicStream$instance;
};


export interface __QuicStream$views {
    As_IAsyncDisposable(): System_Internal.IAsyncDisposable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type QuicStream = QuicStream$instance & __QuicStream$views;