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

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

// 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;