import type { _NSData } from "./NSData.js";
import type { _NSDictionary } from "./NSDictionary.js";
import type { _NSInputStream } from "./NSInputStream.js";
import type { _NSString } from "./NSString.js";
import type { _NSURL } from "./NSURL.js";
import type { _NSURLRequest } from "./NSURLRequest.js";
import type { NSURLRequestAttribution } from "./NSURLRequestAttribution.js";
import type { NSURLRequestCachePolicy } from "./NSURLRequestCachePolicy.js";
import type { NSURLRequestNetworkServiceType } from "./NSURLRequestNetworkServiceType.js";
export declare class _NSMutableURLRequest extends _NSURLRequest {
    static alloc(): _NSMutableURLRequest;
    static new(): _NSMutableURLRequest;
    init(): _NSMutableURLRequest;
    /**
     * @method setValue:forHTTPHeaderField: @abstract Sets the value of the given HTTP header field. @discussion If a value was previously set for the given header field, that value is replaced with the given value. Note that, in keeping with the HTTP RFC, HTTP header field names are case-insensitive. @param value the header field value. @param field the header field name (case-insensitive).
     */
    setValue$forHTTPHeaderField$(value: _NSString | null, field: _NSString): void;
    /**
     * @method addValue:forHTTPHeaderField: @abstract Adds an HTTP header field in the current header dictionary. @discussion This method provides a way to add values to header fields incrementally. If a value was previously set for the given header field, the given value is appended to the previously-existing value. The appropriate field delimiter, a comma in the case of HTTP, is added by the implementation, and should not be added to the given value by the caller. Note that, in keeping with the HTTP RFC, HTTP header field names are case-insensitive. @param value the header field value. @param field the header field name (case-insensitive).
     */
    addValue$forHTTPHeaderField$(value: _NSString, field: _NSString): void;
    /** @abstract The URL of the receiver. */
    URL(): _NSURL | null;
    setURL$(value: _NSURL | null): void;
    /** @abstract The cache policy of the receiver. */
    cachePolicy(): NSURLRequestCachePolicy;
    setCachePolicy$(value: NSURLRequestCachePolicy): void;
    /**
     * @abstract Sets the timeout interval of the receiver. @discussion The timeout interval specifies the limit on the idle interval allotted to a request in the process of loading. The "idle interval" is defined as the period of time that has passed since the last instance of load activity occurred for a request that is in the process of loading. Hence, when an instance of load activity occurs (e.g. bytes are received from the network for a request), the idle interval for a request is reset to 0. If the idle interval ever becomes greater than or equal to the timeout interval, the request is considered to have timed out. This timeout interval is measured in seconds.
     */
    timeoutInterval(): number;
    setTimeoutInterval$(value: number): void;
    /**
     * @abstract Sets the main document URL @discussion The caller should pass the URL for an appropriate main document, if known. For example, when loading a web page, the URL of the main html document for the top-level frame should be passed. This main document is used to implement the cookie "only from same domain as main document" policy, attributing this request as a sub-resource of a user-specified URL, and possibly other things in the future.
     */
    mainDocumentURL(): _NSURL | null;
    setMainDocumentURL$(value: _NSURL | null): void;
    /**
     * @abstract Sets the NSURLRequestNetworkServiceType to associate with this request @discussion This method is used to provide the network layers with a hint as to the purpose of the request. Most clients should not need to use this method.
     */
    networkServiceType(): NSURLRequestNetworkServiceType;
    setNetworkServiceType$(value: NSURLRequestNetworkServiceType): void;
    /**
     * @abstract sets whether a connection created with this request is allowed to use the built in cellular radios (if present). @discussion NO if the receiver should not be allowed to use the built in cellular radios to satisfy the request, YES otherwise. The default is YES.
     */
    allowsCellularAccess(): boolean;
    setAllowsCellularAccess$(value: boolean): void;
    /**
     * @abstract sets whether a connection created with this request is allowed to use network interfaces which have been marked as expensive. @discussion NO if the receiver should not be allowed to use an interface marked as expensive to satisfy the request, YES otherwise.
     */
    allowsExpensiveNetworkAccess(): boolean;
    setAllowsExpensiveNetworkAccess$(value: boolean): void;
    /**
     * @abstract sets whether a connection created with this request is allowed to use network interfaces which have been marked as constrained. @discussion NO if the receiver should not be allowed to use an interface marked as constrained to satisfy the request, YES otherwise.
     */
    allowsConstrainedNetworkAccess(): boolean;
    setAllowsConstrainedNetworkAccess$(value: boolean): void;
    /**
     * @abstract sets whether a connection created with this request is allowed to use network interfaces which have been marked as ultra constrained. @discussion NO if the receiver should not be allowed to use an interface marked as ultra constrained to satisfy the request, YES otherwise.
     */
    allowsUltraConstrainedNetworkAccess(): boolean;
    setAllowsUltraConstrainedNetworkAccess$(value: boolean): void;
    /**
     * @abstract returns whether we assume that server supports HTTP/3. Enables QUIC racing without HTTP/3 service discovery. @result YES if server endpoint is known to support HTTP/3. Defaults to NO. The default may be YES in a future OS update.
     */
    assumesHTTP3Capable(): boolean;
    setAssumesHTTP3Capable$(value: boolean): void;
    /**
     * @abstract Sets the NSURLRequestAttribution to associate with this request. @discussion Set to NSURLRequestAttributionUser if the URL was specified by the user. Defaults to NSURLRequestAttributionDeveloper.
     */
    attribution(): NSURLRequestAttribution;
    setAttribution$(value: NSURLRequestAttribution): void;
    /**
     * @abstract sets whether a request is required to do DNSSEC validation during DNS lookup. @discussion YES, if the DNS lookup for this request should require DNSSEC validation, No otherwise. Defaults to NO.
     */
    requiresDNSSECValidation(): boolean;
    setRequiresDNSSECValidation$(value: boolean): void;
    /**
     * @abstract Allows storing and usage of DNS answers, potentially beyond TTL expiry, in a persistent per-process cache. This should only be set for hostnames whose resolutions are not expected to change across networks. @discussion YES, if the DNS lookup for this request is allowed to use a persistent per-process cache, NO otherwise. Defaults to NO.
     */
    allowsPersistentDNS(): boolean;
    setAllowsPersistentDNS$(value: boolean): void;
    /** Cookie partition identifier used for cookie storage and retrieval. */
    cookiePartitionIdentifier(): _NSString | null;
    setCookiePartitionIdentifier$(value: _NSString | null): void;
    /** @abstract Sets the HTTP request method of the receiver. */
    HTTPMethod(): _NSString;
    setHTTPMethod$(value: _NSString): void;
    /**
     * @abstract Sets the HTTP header fields of the receiver to the given dictionary. @discussion This method replaces all header fields that may have existed before this method call. <p>Since HTTP header fields must be string values, each object and key in the dictionary passed to this method must answer YES when sent an <tt>-isKindOfClass:[NSString class]</tt> message. If either the key or value for a key-value pair answers NO when sent this message, the key-value pair is skipped.
     */
    allHTTPHeaderFields(): _NSDictionary | null;
    setAllHTTPHeaderFields$(value: _NSDictionary | null): void;
    /**
     * @abstract Sets the request body data of the receiver. @discussion This data is sent as the message body of the request, as in done in an HTTP POST request.
     */
    HTTPBody(): _NSData | null;
    setHTTPBody$(value: _NSData | null): void;
    /**
     * @abstract Sets the request body to be the contents of the given stream. @discussion The provided stream should be unopened; the request will take over the stream's delegate. The entire stream's contents will be transmitted as the HTTP body of the request. Note that the body stream and the body data (set by setHTTPBody:, above) are mutually exclusive - setting one will clear the other.
     */
    HTTPBodyStream(): _NSInputStream | null;
    setHTTPBodyStream$(value: _NSInputStream | null): void;
    /**
     * @abstract Decide whether default cookie handling will happen for this request (YES if cookies should be sent with and set for this request; otherwise NO). @discussion The default is YES - in other words, cookies are sent from and stored to the cookie manager by default. NOTE: In releases prior to 10.3, this value is ignored
     */
    HTTPShouldHandleCookies(): boolean;
    setHTTPShouldHandleCookies$(value: boolean): void;
    /**
     * @abstract Sets whether the request should not wait for the previous response before transmitting (YES if the receiver should transmit before the previous response is received. NO to wait for the previous response before transmitting) @discussion Calling this method with a YES value does not guarantee HTTP pipelining behavior. This method may have no effect if an HTTP proxy is configured, or if the HTTP request uses an unsafe request method (e.g., POST requests will not pipeline). Pipelining behavior also may not begin until the second request on a given TCP connection. There may be other situations where pipelining does not occur even though YES was set. HTTP 1.1 allows the client to send multiple requests to the server without waiting for a response. Though HTTP 1.1 requires support for pipelining, some servers report themselves as being HTTP 1.1 but do not support pipelining (disconnecting, sending resources misordered, omitting part of a resource, etc.).
     * @deprecated Only supported in the classic loader, please adopt HTTP/2 and HTTP/3 instead
     */
    HTTPShouldUsePipelining(): boolean;
    setHTTPShouldUsePipelining$(value: boolean): void;
}
