@tsonic/dotnet/System.Net.Http/internal/index.d.ts

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

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

// 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 support types from @tsonic/types
import type { ptr, ref } from "@tsonic/types";

// Import types from other namespaces
import * as System_Collections_Generic_Internal from "../../System.Collections.Generic/internal/index.js";
import type { ICollection_1, IDictionary_2, IEnumerable_1, IEnumerator_1, IReadOnlyCollection_1, IReadOnlyDictionary_2, KeyValuePair_2 } from "../../System.Collections.Generic/internal/index.js";
import * as System_Collections_Internal from "../../System.Collections/internal/index.js";
import type { IDictionary, IEnumerable, IEnumerator } from "../../System.Collections/internal/index.js";
import type { IMeterFactory } from "../../System.Diagnostics.Metrics/internal/index.js";
import type { DistributedContextPropagator } from "../../System.Diagnostics/internal/index.js";
import * as System_IO_Internal from "../../System.IO/internal/index.js";
import type { IOException, Stream } from "../../System.IO/internal/index.js";
import type { HttpContentHeaders, HttpRequestHeaders, HttpResponseHeaders, MediaTypeHeaderValue } from "../../System.Net.Http.Headers/internal/index.js";
import type { SslClientAuthenticationOptions, SslPolicyErrors } from "../../System.Net.Security/internal/index.js";
import type { CookieContainer, DecompressionMethods, DnsEndPoint, HttpStatusCode, ICredentials, IWebProxy, TransportContext } from "../../System.Net/internal/index.js";
import type { MethodBase, MethodInfo } 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 { X509Certificate2, X509CertificateCollection, X509Chain } from "../../System.Security.Cryptography.X509Certificates/internal/index.js";
import type { Encoding } from "../../System.Text/internal/index.js";
import type { Task, Task_1, 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 { AsyncCallback, Boolean as ClrBoolean, Byte, Char, Delegate, Enum, Exception, Func_3, Func_5, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IEquatable_1, IFormatProvider, IFormattable, Int32, Int64, IntPtr, ISpanFormattable, MulticastDelegate, Nullable_1, Object as ClrObject, ReadOnlyMemory_1, ReadOnlySpan_1, String as ClrString, TimeSpan, Type, TypeCode, Uri, ValueType, Version, 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 ClientCertificateOption {
    manual = 0,
    automatic = 1
}


export enum HttpCompletionOption {
    responseContentRead = 0,
    responseHeadersRead = 1
}


export enum HttpKeepAlivePingPolicy {
    withActiveRequests = 0,
    always = 1
}


export enum HttpRequestError {
    unknown_ = 0,
    nameResolutionError = 1,
    connectionError = 2,
    secureConnectionError = 3,
    httpProtocolError = 4,
    extendedConnectNotSupported = 5,
    versionNegotiationError = 6,
    userAuthenticationError = 7,
    proxyTunnelError = 8,
    invalidResponse = 9,
    responseEnded = 10,
    configurationLimitExceeded = 11
}


export enum HttpVersionPolicy {
    requestVersionOrLower = 0,
    requestVersionOrHigher = 1,
    requestVersionExact = 2
}


export type HeaderEncodingSelector_1<TContext> = (headerName: string, context: TContext) => Encoding;


export interface HttpRequestOptionsKey_1$instance<TValue> {
    readonly key: string;
}


export const HttpRequestOptionsKey_1: {
    new<TValue>(key: string): HttpRequestOptionsKey_1$instance<TValue>;
};


export type HttpRequestOptionsKey_1<TValue> = HttpRequestOptionsKey_1$instance<TValue>;

export interface ByteArrayContent$instance extends HttpContent$instance {
    dispose(): void;
}


export const ByteArrayContent: {
    new(content: byte[]): ByteArrayContent$instance;
    new(content: byte[], offset: int, count: int): ByteArrayContent$instance;
};


export interface __ByteArrayContent$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type ByteArrayContent = ByteArrayContent$instance & __ByteArrayContent$views;


export interface DelegatingHandler$instance extends HttpMessageHandler$instance {
    innerHandler: HttpMessageHandler;
    dispose(): void;
}


export const DelegatingHandler: {
};


export interface __DelegatingHandler$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type DelegatingHandler = DelegatingHandler$instance & __DelegatingHandler$views;


export interface FormUrlEncodedContent$instance extends ByteArrayContent$instance {
    dispose(): void;
}


export const FormUrlEncodedContent: {
    new(nameValueCollection: IEnumerable_1<KeyValuePair_2<CLROf<string>, CLROf<string>>>): FormUrlEncodedContent$instance;
};


export interface __FormUrlEncodedContent$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type FormUrlEncodedContent = FormUrlEncodedContent$instance & __FormUrlEncodedContent$views;


export interface HttpClient$instance extends HttpMessageInvoker$instance {
    baseAddress: Uri;
    readonly defaultRequestHeaders: HttpRequestHeaders;
    defaultRequestVersion: Version;
    defaultVersionPolicy: HttpVersionPolicy;
    maxResponseContentBufferSize: long;
    timeout: TimeSpan;
    cancelPendingRequests(): void;
    deleteAsync(requestUri: string): Task_1<HttpResponseMessage>;
    deleteAsync(requestUri: Uri): Task_1<HttpResponseMessage>;
    deleteAsync(requestUri: string, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    deleteAsync(requestUri: Uri, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    dispose(): void;
    getAsync(requestUri: string): Task_1<HttpResponseMessage>;
    getAsync(requestUri: Uri): Task_1<HttpResponseMessage>;
    getAsync(requestUri: string, completionOption: HttpCompletionOption): Task_1<HttpResponseMessage>;
    getAsync(requestUri: Uri, completionOption: HttpCompletionOption): Task_1<HttpResponseMessage>;
    getAsync(requestUri: string, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    getAsync(requestUri: Uri, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    getAsync(requestUri: string, completionOption: HttpCompletionOption, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    getAsync(requestUri: Uri, completionOption: HttpCompletionOption, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    getByteArrayAsync(requestUri: string): Task_1<byte[]>;
    getByteArrayAsync(requestUri: Uri): Task_1<byte[]>;
    getByteArrayAsync(requestUri: string, cancellationToken: CancellationToken): Task_1<byte[]>;
    getByteArrayAsync(requestUri: Uri, cancellationToken: CancellationToken): Task_1<byte[]>;
    getStreamAsync(requestUri: string): Task_1<Stream>;
    getStreamAsync(requestUri: string, cancellationToken: CancellationToken): Task_1<Stream>;
    getStreamAsync(requestUri: Uri): Task_1<Stream>;
    getStreamAsync(requestUri: Uri, cancellationToken: CancellationToken): Task_1<Stream>;
    getStringAsync(requestUri: string): Task_1<CLROf<string>>;
    getStringAsync(requestUri: Uri): Task_1<CLROf<string>>;
    getStringAsync(requestUri: string, cancellationToken: CancellationToken): Task_1<CLROf<string>>;
    getStringAsync(requestUri: Uri, cancellationToken: CancellationToken): Task_1<CLROf<string>>;
    patchAsync(requestUri: string, content: HttpContent): Task_1<HttpResponseMessage>;
    patchAsync(requestUri: Uri, content: HttpContent): Task_1<HttpResponseMessage>;
    patchAsync(requestUri: string, content: HttpContent, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    patchAsync(requestUri: Uri, content: HttpContent, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    postAsync(requestUri: string, content: HttpContent): Task_1<HttpResponseMessage>;
    postAsync(requestUri: Uri, content: HttpContent): Task_1<HttpResponseMessage>;
    postAsync(requestUri: string, content: HttpContent, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    postAsync(requestUri: Uri, content: HttpContent, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    putAsync(requestUri: string, content: HttpContent): Task_1<HttpResponseMessage>;
    putAsync(requestUri: Uri, content: HttpContent): Task_1<HttpResponseMessage>;
    putAsync(requestUri: string, content: HttpContent, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    putAsync(requestUri: Uri, content: HttpContent, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    send(request: HttpRequestMessage, cancellationToken: CancellationToken): HttpResponseMessage;
    sendAsync(request: HttpRequestMessage, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
    sendAsync(request: HttpRequestMessage, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
}


export const HttpClient: {
    new(): HttpClient$instance;
    new(handler: HttpMessageHandler): HttpClient$instance;
    new(handler: HttpMessageHandler, disposeHandler: boolean): HttpClient$instance;
    defaultProxy: IWebProxy;
};


export interface __HttpClient$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type HttpClient = HttpClient$instance & __HttpClient$views;


export interface HttpClientHandler$instance extends HttpMessageHandler$instance {
    allowAutoRedirect: boolean;
    automaticDecompression: DecompressionMethods;
    checkCertificateRevocationList: boolean;
    clientCertificateOptions: ClientCertificateOption;
    readonly clientCertificates: X509CertificateCollection;
    cookieContainer: CookieContainer;
    credentials: ICredentials;
    defaultProxyCredentials: ICredentials;
    maxAutomaticRedirections: int;
    maxConnectionsPerServer: int;
    maxRequestContentBufferSize: long;
    maxResponseHeadersLength: int;
    meterFactory: IMeterFactory;
    preAuthenticate: boolean;
    readonly properties: IDictionary_2<CLROf<string>, unknown>;
    proxy: IWebProxy;
    serverCertificateCustomValidationCallback: Func_5<HttpRequestMessage, X509Certificate2, X509Chain, SslPolicyErrors, CLROf<boolean>>;
    sslProtocols: SslProtocols;
    readonly supportsAutomaticDecompression: boolean;
    readonly supportsProxy: boolean;
    readonly supportsRedirectConfiguration: boolean;
    useCookies: boolean;
    useDefaultCredentials: boolean;
    useProxy: boolean;
    dispose(): void;
}


export const HttpClientHandler: {
    new(): HttpClientHandler$instance;
    readonly dangerousAcceptAnyServerCertificateValidator: Func_5<HttpRequestMessage, X509Certificate2, X509Chain, SslPolicyErrors, CLROf<boolean>>;
};


export interface __HttpClientHandler$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type HttpClientHandler = HttpClientHandler$instance & __HttpClientHandler$views;


export interface HttpContent$instance {
    readonly headers: HttpContentHeaders;
    copyTo(stream: Stream, context: TransportContext, cancellationToken: CancellationToken): void;
    copyToAsync(stream: Stream): Task;
    copyToAsync(stream: Stream, cancellationToken: CancellationToken): Task;
    copyToAsync(stream: Stream, context: TransportContext): Task;
    copyToAsync(stream: Stream, context: TransportContext, cancellationToken: CancellationToken): Task;
    dispose(): void;
    loadIntoBufferAsync(): Task;
    loadIntoBufferAsync(maxBufferSize: long): Task;
    loadIntoBufferAsync(cancellationToken: CancellationToken): Task;
    loadIntoBufferAsync(maxBufferSize: long, cancellationToken: CancellationToken): Task;
    readAsByteArrayAsync(): Task_1<byte[]>;
    readAsByteArrayAsync(cancellationToken: CancellationToken): Task_1<byte[]>;
    readAsStream(): Stream;
    readAsStream(cancellationToken: CancellationToken): Stream;
    readAsStreamAsync(): Task_1<Stream>;
    readAsStreamAsync(cancellationToken: CancellationToken): Task_1<Stream>;
    readAsStringAsync(): Task_1<CLROf<string>>;
    readAsStringAsync(cancellationToken: CancellationToken): Task_1<CLROf<string>>;
}


export const HttpContent: {
};


export interface __HttpContent$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface HttpContent$instance extends System_Internal.IDisposable$instance {}

export type HttpContent = HttpContent$instance & __HttpContent$views;


export interface HttpIOException$instance extends IOException {
    readonly httpRequestError: HttpRequestError;
    readonly message: string;
    getObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const HttpIOException: {
    new(httpRequestError: HttpRequestError, message: string, innerException: Exception): HttpIOException$instance;
};


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

export type HttpIOException = HttpIOException$instance & __HttpIOException$views;


export interface HttpMessageHandler$instance {
    dispose(): void;
}


export const HttpMessageHandler: {
};


export interface __HttpMessageHandler$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface HttpMessageHandler$instance extends System_Internal.IDisposable$instance {}

export type HttpMessageHandler = HttpMessageHandler$instance & __HttpMessageHandler$views;


export interface HttpMessageInvoker$instance {
    dispose(): void;
    send(request: HttpRequestMessage, cancellationToken: CancellationToken): HttpResponseMessage;
    sendAsync(request: HttpRequestMessage, cancellationToken: CancellationToken): Task_1<HttpResponseMessage>;
}


export const HttpMessageInvoker: {
    new(handler: HttpMessageHandler): HttpMessageInvoker$instance;
    new(handler: HttpMessageHandler, disposeHandler: boolean): HttpMessageInvoker$instance;
};


export interface __HttpMessageInvoker$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface HttpMessageInvoker$instance extends System_Internal.IDisposable$instance {}

export type HttpMessageInvoker = HttpMessageInvoker$instance & __HttpMessageInvoker$views;


export interface HttpMethod$instance {
    readonly method: string;
    equals(other: HttpMethod): boolean;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    toString(): string;
}


export const HttpMethod: {
    new(method: string): HttpMethod$instance;
    readonly get_: HttpMethod;
    readonly put: HttpMethod;
    readonly post: HttpMethod;
    readonly delete_: HttpMethod;
    readonly head: HttpMethod;
    readonly options: HttpMethod;
    readonly trace: HttpMethod;
    readonly patch: HttpMethod;
    readonly query: HttpMethod;
    readonly connect: HttpMethod;
    parse(method: ReadOnlySpan_1<CLROf<char>>): HttpMethod;
};


export interface __HttpMethod$views {
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<HttpMethod>;

    // Structural method bridges for numeric interface constraints
    Equals(other: HttpMethod): boolean;
}

export type HttpMethod = HttpMethod$instance & __HttpMethod$views;


export interface HttpProtocolException$instance extends HttpIOException$instance {
    readonly errorCode: long;
    getObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const HttpProtocolException: {
    new(errorCode: long, message: string, innerException: Exception): HttpProtocolException$instance;
};


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

export type HttpProtocolException = HttpProtocolException$instance & __HttpProtocolException$views;


export interface HttpRequestException$instance extends Exception {
    readonly httpRequestError: HttpRequestError;
    readonly statusCode: Nullable_1<HttpStatusCode>;
    getObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const HttpRequestException: {
    new(): HttpRequestException$instance;
    new(message: string): HttpRequestException$instance;
    new(message: string, inner: Exception): HttpRequestException$instance;
    new(message: string, inner: Exception, statusCode: Nullable_1<HttpStatusCode>): HttpRequestException$instance;
    new(httpRequestError: HttpRequestError, message: string, inner: Exception, statusCode: Nullable_1<HttpStatusCode>): HttpRequestException$instance;
};


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

export type HttpRequestException = HttpRequestException$instance & __HttpRequestException$views;


export interface HttpRequestMessage$instance {
    content: HttpContent;
    readonly headers: HttpRequestHeaders;
    method: HttpMethod;
    readonly options: HttpRequestOptions;
    readonly properties: IDictionary_2<CLROf<string>, unknown>;
    requestUri: Uri;
    version: Version;
    versionPolicy: HttpVersionPolicy;
    dispose(): void;
    toString(): string;
}


export const HttpRequestMessage: {
    new(): HttpRequestMessage$instance;
    new(method: HttpMethod, requestUri: Uri): HttpRequestMessage$instance;
    new(method: HttpMethod, requestUri: string): HttpRequestMessage$instance;
};


export interface __HttpRequestMessage$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface HttpRequestMessage$instance extends System_Internal.IDisposable$instance {}

export type HttpRequestMessage = HttpRequestMessage$instance & __HttpRequestMessage$views;


export interface HttpRequestOptions$instance {
    set_<TValue>(key: HttpRequestOptionsKey_1<TValue>, value: TValue): void;
    tryGetValue<TValue>(key: HttpRequestOptionsKey_1<TValue>, value: { value: ref<TValue> }): boolean;
}


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


export interface __HttpRequestOptions$views {
    As_ICollection_1(): System_Collections_Generic_Internal.ICollection_1$instance<KeyValuePair_2<CLROf<string>, unknown>>;
    As_IDictionary_2(): System_Collections_Generic_Internal.IDictionary_2$instance<CLROf<string>, unknown>;
    As_IEnumerable_1(): System_Collections_Generic_Internal.IEnumerable_1$instance<KeyValuePair_2<CLROf<string>, unknown>>;
    As_IReadOnlyCollection_1(): System_Collections_Generic_Internal.IReadOnlyCollection_1$instance<KeyValuePair_2<CLROf<string>, unknown>>;
    As_IReadOnlyDictionary_2(): System_Collections_Generic_Internal.IReadOnlyDictionary_2$instance<CLROf<string>, unknown>;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export type HttpRequestOptions = HttpRequestOptions$instance & __HttpRequestOptions$views;


export interface HttpResponseMessage$instance {
    content: HttpContent;
    readonly headers: HttpResponseHeaders;
    readonly isSuccessStatusCode: boolean;
    reasonPhrase: string;
    requestMessage: HttpRequestMessage;
    statusCode: HttpStatusCode;
    readonly trailingHeaders: HttpResponseHeaders;
    version: Version;
    dispose(): void;
    ensureSuccessStatusCode(): HttpResponseMessage;
    toString(): string;
}


export const HttpResponseMessage: {
    new(): HttpResponseMessage$instance;
    new(statusCode: HttpStatusCode): HttpResponseMessage$instance;
};


export interface __HttpResponseMessage$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface HttpResponseMessage$instance extends System_Internal.IDisposable$instance {}

export type HttpResponseMessage = HttpResponseMessage$instance & __HttpResponseMessage$views;


export interface MessageProcessingHandler$instance extends DelegatingHandler$instance {
    dispose(): void;
}


export const MessageProcessingHandler: {
};


export interface __MessageProcessingHandler$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type MessageProcessingHandler = MessageProcessingHandler$instance & __MessageProcessingHandler$views;


export interface MultipartContent$instance extends HttpContent$instance {
    headerEncodingSelector: HeaderEncodingSelector_1<HttpContent>;
    add(content: HttpContent): void;
    dispose(): void;
    getEnumerator(): IEnumerator_1<HttpContent>;
}


export const MultipartContent: {
    new(): MultipartContent$instance;
    new(subtype: string): MultipartContent$instance;
    new(subtype: string, boundary: string): MultipartContent$instance;
};


export interface __MultipartContent$views {
    As_IEnumerable_1(): System_Collections_Generic_Internal.IEnumerable_1$instance<HttpContent>;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type MultipartContent = MultipartContent$instance & __MultipartContent$views;


export interface MultipartFormDataContent$instance extends MultipartContent$instance {
    add(content: HttpContent): void;
    dispose(): void;
    getEnumerator(): IEnumerator_1<HttpContent>;
    getEnumerator(): IEnumerator;
}


export const MultipartFormDataContent: {
    new(): MultipartFormDataContent$instance;
    new(boundary: string): MultipartFormDataContent$instance;
};


export interface __MultipartFormDataContent$views {
    As_IEnumerable_1(): System_Collections_Generic_Internal.IEnumerable_1$instance<HttpContent>;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type MultipartFormDataContent = MultipartFormDataContent$instance & __MultipartFormDataContent$views;


export interface ReadOnlyMemoryContent$instance extends HttpContent$instance {
    dispose(): void;
}


export const ReadOnlyMemoryContent: {
    new(content: ReadOnlyMemory_1<CLROf<byte>>): ReadOnlyMemoryContent$instance;
};


export interface __ReadOnlyMemoryContent$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type ReadOnlyMemoryContent = ReadOnlyMemoryContent$instance & __ReadOnlyMemoryContent$views;


export interface SocketsHttpConnectionContext$instance {
    readonly dnsEndPoint: DnsEndPoint;
    readonly initialRequestMessage: HttpRequestMessage;
}


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


export type SocketsHttpConnectionContext = SocketsHttpConnectionContext$instance;

export interface SocketsHttpHandler$instance extends HttpMessageHandler$instance {
    activityHeadersPropagator: DistributedContextPropagator;
    allowAutoRedirect: boolean;
    automaticDecompression: DecompressionMethods;
    connectCallback: Func_3<SocketsHttpConnectionContext, CancellationToken, ValueTask_1<Stream>>;
    connectTimeout: TimeSpan;
    cookieContainer: CookieContainer;
    credentials: ICredentials;
    defaultProxyCredentials: ICredentials;
    enableMultipleHttp2Connections: boolean;
    enableMultipleHttp3Connections: boolean;
    expect100ContinueTimeout: TimeSpan;
    initialHttp2StreamWindowSize: int;
    keepAlivePingDelay: TimeSpan;
    keepAlivePingPolicy: HttpKeepAlivePingPolicy;
    keepAlivePingTimeout: TimeSpan;
    maxAutomaticRedirections: int;
    maxConnectionsPerServer: int;
    maxResponseDrainSize: int;
    maxResponseHeadersLength: int;
    meterFactory: IMeterFactory;
    plaintextStreamFilter: Func_3<SocketsHttpPlaintextStreamFilterContext, CancellationToken, ValueTask_1<Stream>>;
    pooledConnectionIdleTimeout: TimeSpan;
    pooledConnectionLifetime: TimeSpan;
    preAuthenticate: boolean;
    readonly properties: IDictionary_2<CLROf<string>, unknown>;
    proxy: IWebProxy;
    requestHeaderEncodingSelector: HeaderEncodingSelector_1<HttpRequestMessage>;
    responseDrainTimeout: TimeSpan;
    responseHeaderEncodingSelector: HeaderEncodingSelector_1<HttpRequestMessage>;
    sslOptions: SslClientAuthenticationOptions;
    useCookies: boolean;
    useProxy: boolean;
    dispose(): void;
}


export const SocketsHttpHandler: {
    new(): SocketsHttpHandler$instance;
    readonly isSupported: boolean;
};


export interface __SocketsHttpHandler$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type SocketsHttpHandler = SocketsHttpHandler$instance & __SocketsHttpHandler$views;


export interface SocketsHttpPlaintextStreamFilterContext$instance {
    readonly initialRequestMessage: HttpRequestMessage;
    readonly negotiatedHttpVersion: Version;
    readonly plaintextStream: Stream;
}


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


export type SocketsHttpPlaintextStreamFilterContext = SocketsHttpPlaintextStreamFilterContext$instance;

export interface StreamContent$instance extends HttpContent$instance {
    dispose(): void;
}


export const StreamContent: {
    new(content: Stream): StreamContent$instance;
    new(content: Stream, bufferSize: int): StreamContent$instance;
};


export interface __StreamContent$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type StreamContent = StreamContent$instance & __StreamContent$views;


export interface StringContent$instance extends ByteArrayContent$instance {
    dispose(): void;
}


export const StringContent: {
    new(content: string): StringContent$instance;
    new(content: string, mediaType: MediaTypeHeaderValue): StringContent$instance;
    new(content: string, encoding: Encoding): StringContent$instance;
    new(content: string, encoding: Encoding, mediaType: string): StringContent$instance;
    new(content: string, encoding: Encoding, mediaType: MediaTypeHeaderValue): StringContent$instance;
};


export interface __StringContent$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type StringContent = StringContent$instance & __StringContent$views;