Full Code of 0x676e67/rquest for AI

gitextract_e98nv8b_/

├── .github/
│   ├── FUNDING.yml
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   └── feature_request.md
│   ├── compilation-guide/
│   │   └── build.yml
│   ├── dependabot.yml
│   └── workflows/
│       └── ci.yml
├── .gitignore
├── Cargo.toml
├── LICENSE
├── README.md
├── RELEASE.md
├── bench/
│   ├── http1.rs
│   ├── http1_over_tls.rs
│   ├── http2.rs
│   ├── http2_over_tls.rs
│   ├── support/
│   │   ├── bench.rs
│   │   ├── client.rs
│   │   └── server.rs
│   └── support.rs
├── cliff.toml
├── examples/
│   ├── cert_store.rs
│   ├── connect_via_lower_priority_tokio_runtime.rs
│   ├── emulate.rs
│   ├── form.rs
│   ├── http1_websocket.rs
│   ├── http2_websocket.rs
│   ├── json_dynamic.rs
│   ├── json_typed.rs
│   ├── keylog.rs
│   ├── request_with_emulate.rs
│   ├── request_with_interface.rs
│   ├── request_with_local_address.rs
│   ├── request_with_proxy.rs
│   ├── request_with_redirect.rs
│   ├── request_with_version.rs
│   ├── tor_socks.rs
│   └── unix_socket.rs
├── rustfmt.toml
├── src/
│   ├── client/
│   │   ├── body.rs
│   │   ├── conn/
│   │   │   ├── connector.rs
│   │   │   ├── descriptor.rs
│   │   │   ├── http.rs
│   │   │   ├── proxy/
│   │   │   │   ├── socks.rs
│   │   │   │   └── tunnel.rs
│   │   │   ├── proxy.rs
│   │   │   ├── tcp/
│   │   │   │   └── tokio.rs
│   │   │   ├── tcp.rs
│   │   │   ├── tls_info.rs
│   │   │   ├── uds.rs
│   │   │   └── verbose.rs
│   │   ├── conn.rs
│   │   ├── core/
│   │   │   ├── body/
│   │   │   │   ├── incoming.rs
│   │   │   │   ├── length.rs
│   │   │   │   └── watch.rs
│   │   │   ├── body.rs
│   │   │   ├── conn/
│   │   │   │   ├── http1.rs
│   │   │   │   └── http2.rs
│   │   │   ├── conn.rs
│   │   │   ├── dispatch.rs
│   │   │   ├── error.rs
│   │   │   ├── proto/
│   │   │   │   ├── headers.rs
│   │   │   │   ├── http1/
│   │   │   │   │   ├── buf.rs
│   │   │   │   │   ├── conn.rs
│   │   │   │   │   ├── decode.rs
│   │   │   │   │   ├── dispatch.rs
│   │   │   │   │   ├── encode.rs
│   │   │   │   │   ├── ext.rs
│   │   │   │   │   ├── io.rs
│   │   │   │   │   └── role.rs
│   │   │   │   ├── http1.rs
│   │   │   │   ├── http2/
│   │   │   │   │   ├── client.rs
│   │   │   │   │   └── ping.rs
│   │   │   │   └── http2.rs
│   │   │   ├── proto.rs
│   │   │   ├── rt/
│   │   │   │   ├── bounds.rs
│   │   │   │   ├── timer.rs
│   │   │   │   └── tokio.rs
│   │   │   ├── rt.rs
│   │   │   └── upgrade.rs
│   │   ├── core.rs
│   │   ├── emulate.rs
│   │   ├── future.rs
│   │   ├── group.rs
│   │   ├── layer/
│   │   │   ├── client/
│   │   │   │   ├── exec.rs
│   │   │   │   ├── lazy.rs
│   │   │   │   └── pool.rs
│   │   │   ├── client.rs
│   │   │   ├── config.rs
│   │   │   ├── decoder.rs
│   │   │   ├── redirect/
│   │   │   │   ├── future.rs
│   │   │   │   └── policy.rs
│   │   │   ├── redirect.rs
│   │   │   ├── retry/
│   │   │   │   ├── classify.rs
│   │   │   │   └── scope.rs
│   │   │   ├── retry.rs
│   │   │   ├── timeout/
│   │   │   │   ├── body.rs
│   │   │   │   └── future.rs
│   │   │   └── timeout.rs
│   │   ├── layer.rs
│   │   ├── multipart.rs
│   │   ├── request.rs
│   │   ├── response.rs
│   │   ├── ws/
│   │   │   ├── json.rs
│   │   │   └── message.rs
│   │   └── ws.rs
│   ├── client.rs
│   ├── config.rs
│   ├── cookie.rs
│   ├── dns/
│   │   ├── gai.rs
│   │   ├── hickory.rs
│   │   └── resolve.rs
│   ├── dns.rs
│   ├── error.rs
│   ├── ext.rs
│   ├── header.rs
│   ├── into_uri.rs
│   ├── lib.rs
│   ├── proxy/
│   │   ├── mac.rs
│   │   ├── matcher.rs
│   │   ├── uds.rs
│   │   └── win.rs
│   ├── proxy.rs
│   ├── redirect.rs
│   ├── retry.rs
│   ├── sync.rs
│   ├── tls/
│   │   ├── compress.rs
│   │   ├── conn/
│   │   │   ├── ext.rs
│   │   │   ├── macros.rs
│   │   │   └── service.rs
│   │   ├── conn.rs
│   │   ├── keylog/
│   │   │   └── handle.rs
│   │   ├── keylog.rs
│   │   ├── session.rs
│   │   ├── trust/
│   │   │   ├── identity.rs
│   │   │   ├── parse.rs
│   │   │   └── store.rs
│   │   └── trust.rs
│   ├── tls.rs
│   ├── trace.rs
│   └── util.rs
└── tests/
    ├── badssl.rs
    ├── brotli.rs
    ├── client.rs
    ├── connector_layers.rs
    ├── cookie.rs
    ├── deflate.rs
    ├── emulate.rs
    ├── gzip.rs
    ├── layers.rs
    ├── multipart.rs
    ├── proxy.rs
    ├── redirect.rs
    ├── retry.rs
    ├── support/
    │   ├── crl.pem
    │   ├── delay_server.rs
    │   ├── error.rs
    │   ├── layer.rs
    │   ├── mod.rs
    │   ├── server.cert
    │   ├── server.key
    │   └── server.rs
    ├── timeouts.rs
    ├── unix_socket.rs
    ├── upgrade.rs
    └── zstd.rs

SYMBOL INDEX (2585 symbols across 143 files)

FILE: bench/http1.rs
  constant NUM_REQUESTS_TO_SEND (line 10) | const NUM_REQUESTS_TO_SEND: usize = 500;
  function bench (line 13) | fn bench(c: &mut Criterion) {

FILE: bench/http1_over_tls.rs
  constant NUM_REQUESTS_TO_SEND (line 10) | const NUM_REQUESTS_TO_SEND: usize = 500;
  function bench (line 13) | fn bench(c: &mut Criterion) {

FILE: bench/http2.rs
  constant NUM_REQUESTS_TO_SEND (line 10) | const NUM_REQUESTS_TO_SEND: usize = 500;
  function bench (line 13) | fn bench(c: &mut Criterion) {

FILE: bench/http2_over_tls.rs
  constant NUM_REQUESTS_TO_SEND (line 10) | const NUM_REQUESTS_TO_SEND: usize = 500;
  function bench (line 13) | fn bench(c: &mut Criterion) {

FILE: bench/support.rs
  type BoxError (line 7) | pub type BoxError = Box<dyn std::error::Error + Send + Sync>;
  type HttpVersion (line 11) | pub enum HttpVersion {
    method fmt (line 17) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Tls (line 28) | pub enum Tls {
    method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function current_thread_runtime (line 43) | pub fn current_thread_runtime() -> tokio::runtime::Runtime {
  function multi_thread_runtime (line 50) | pub fn multi_thread_runtime() -> tokio::runtime::Runtime {

FILE: bench/support/bench.rs
  constant CURRENT_THREAD_LABEL (line 8) | pub const CURRENT_THREAD_LABEL: &str = "current_thread";
  constant MULTI_THREAD_LABEL (line 9) | pub const MULTI_THREAD_LABEL: &str = "multi_thread";
  constant CONCURRENT_CASES (line 10) | pub const CONCURRENT_CASES: &[usize] = &[10, 50, 100, 150];
  constant BODY_CASES (line 20) | pub const BODY_CASES: [(&[u8], usize); 7] = [
  function bench (line 30) | pub fn bench(

FILE: bench/support/client.rs
  function create_wreq_client (line 10) | fn create_wreq_client(tls: Tls, http_version: HttpVersion) -> Result<wre...
  function create_reqwest_client (line 24) | fn create_reqwest_client(tls: Tls, http_version: HttpVersion) -> Result<...
  function wreq_body_assert (line 38) | async fn wreq_body_assert(mut response: wreq::Response, expected_body_si...
  function reqwest_body_assert (line 51) | async fn reqwest_body_assert(mut response: reqwest::Response, expected_b...
  function stream_from_bytes (line 62) | fn stream_from_bytes(
  function wreq_body (line 78) | fn wreq_body(stream: bool, (body, chunk_size): (&'static [u8], usize)) -...
  function reqwest_body (line 88) | fn reqwest_body(stream: bool, (body, chunk_size): (&'static [u8], usize)...
  function wreq_requests_concurrent (line 97) | async fn wreq_requests_concurrent(
  function reqwest_requests_concurrent (line 129) | async fn reqwest_requests_concurrent(
  function bench_clients (line 162) | pub fn bench_clients(

FILE: bench/support/server.rs
  type Server (line 25) | pub struct Server {
    method new (line 32) | pub fn new(tls: Tls) -> Result<Self, BoxError> {
    method local_addr (line 67) | fn local_addr(&self) -> io::Result<SocketAddr> {
    method run (line 71) | async fn run(self, mut shutdown: oneshot::Receiver<()>) -> Result<(), ...
  type Handle (line 106) | pub struct Handle {
    method shutdown (line 112) | pub fn shutdown(self) {
  function with_server (line 118) | pub fn with_server<F>(tls: Tls, f: F) -> Result<(), BoxError>
  function serve (line 147) | async fn serve<S>(builder: Builder<TokioExecutor>, stream: S)
  function handle_connection (line 167) | async fn handle_connection(

FILE: examples/cert_store.rs
  function main (line 39) | async fn main() -> wreq::Result<()> {

FILE: examples/connect_via_lower_priority_tokio_runtime.rs
  function main (line 19) | async fn main() -> wreq::Result<()> {
  function init_background_runtime (line 70) | pub(crate) fn init_background_runtime() {
  function process_cpu_work (line 105) | async fn process_cpu_work() {
  function send_to_background_runtime (line 117) | fn send_to_background_runtime(future: impl Future<Output = ()> + Send + ...
  type BackgroundProcessorLayer (line 146) | pub struct BackgroundProcessorLayer {}
    method new (line 148) | pub fn new() -> Self {
    type Service (line 153) | type Service = BackgroundProcessor<S>;
    method layer (line 154) | fn layer(&self, service: S) -> Self::Service {
    method fmt (line 160) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type BackgroundProcessor (line 168) | pub struct BackgroundProcessor<S> {
  function new (line 173) | pub fn new(inner: S) -> Self {
  type Response (line 185) | type Response = S::Response;
  type Error (line 187) | type Error = BoxError;
  type Future (line 189) | type Future = BackgroundResponseFuture<S::Response>;
    type Output (line 243) | type Output = Result<S, BoxError>;
    method poll (line 245) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 191) | fn poll_ready(
  function call (line 201) | fn call(&mut self, req: Request) -> Self::Future {
  function new (line 234) | pub(crate) fn new(rx: tokio::sync::oneshot::Receiver<Result<S, BoxError>...

FILE: examples/emulate.rs
  function main (line 15) | async fn main() -> wreq::Result<()> {

FILE: examples/form.rs
  function main (line 7) | async fn main() {

FILE: examples/http1_websocket.rs
  function main (line 5) | async fn main() -> wreq::Result<()> {

FILE: examples/http2_websocket.rs
  function main (line 12) | async fn main() -> wreq::Result<()> {

FILE: examples/json_dynamic.rs
  function main (line 11) | async fn main() -> wreq::Result<()> {

FILE: examples/json_typed.rs
  type Post (line 11) | struct Post {
  function main (line 23) | async fn main() -> wreq::Result<()> {

FILE: examples/keylog.rs
  function main (line 4) | async fn main() -> wreq::Result<()> {

FILE: examples/request_with_emulate.rs
  function main (line 15) | async fn main() -> wreq::Result<()> {

FILE: examples/request_with_interface.rs
  function main (line 14) | async fn main() -> wreq::Result<()> {
  function main (line 37) | fn main() {}

FILE: examples/request_with_local_address.rs
  function main (line 6) | async fn main() -> wreq::Result<()> {

FILE: examples/request_with_proxy.rs
  function main (line 4) | async fn main() -> wreq::Result<()> {

FILE: examples/request_with_redirect.rs
  function main (line 4) | async fn main() -> wreq::Result<()> {

FILE: examples/request_with_version.rs
  function main (line 4) | async fn main() -> wreq::Result<()> {

FILE: examples/tor_socks.rs
  function main (line 7) | async fn main() -> wreq::Result<()> {

FILE: examples/unix_socket.rs
  function main (line 3) | async fn main() -> wreq::Result<()> {
  function main (line 33) | fn main() {}

FILE: src/client.rs
  type Decompression (line 108) | type Decompression<T> = T;
  type Decompression (line 117) | type Decompression<T> = self::layer::decoder::Decompression<T>;
  type ResponseBody (line 126) | type ResponseBody = TimeoutBody<tower_http::decompression::Decompression...
  type ResponseBody (line 135) | type ResponseBody = TimeoutBody<Incoming>;
  type ClientService (line 138) | type ClientService = Timeout<
  type BoxedClientService (line 152) | type BoxedClientService =
  type BoxedClientLayer (line 156) | type BoxedClientLayer = BoxCloneSyncServiceLayer<
  type Client (line 178) | pub struct Client(Arc<Either<ClientService, BoxedClientService>>);
    method new (line 271) | pub fn new() -> Client {
    method builder (line 276) | pub fn builder() -> ClientBuilder {
    method get (line 344) | pub fn get<U: IntoUri>(&self, uri: U) -> RequestBuilder {
    method post (line 354) | pub fn post<U: IntoUri>(&self, uri: U) -> RequestBuilder {
    method put (line 364) | pub fn put<U: IntoUri>(&self, uri: U) -> RequestBuilder {
    method patch (line 374) | pub fn patch<U: IntoUri>(&self, uri: U) -> RequestBuilder {
    method delete (line 384) | pub fn delete<U: IntoUri>(&self, uri: U) -> RequestBuilder {
    method head (line 394) | pub fn head<U: IntoUri>(&self, uri: U) -> RequestBuilder {
    method options (line 404) | pub fn options<U: IntoUri>(&self, uri: U) -> RequestBuilder {
    method request (line 416) | pub fn request<U: IntoUri>(&self, method: Method, uri: U) -> RequestBu...
    method websocket (line 428) | pub fn websocket<U: IntoUri>(&self, uri: U) -> WebSocketRequestBuilder {
    method execute (line 444) | pub fn execute(&self, request: Request) -> Pending {
    type Response (line 454) | type Response = Response;
    type Error (line 455) | type Error = Error;
    type Future (line 456) | type Future = Pending;
    method poll_ready (line 459) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Sel...
    method call (line 464) | fn call(&mut self, req: Request) -> Self::Future {
  type ClientBuilder (line 182) | pub struct ClientBuilder {
    method build (line 494) | pub fn build(self) -> crate::Result<Client> {
    method user_agent (line 680) | pub fn user_agent<V>(mut self, value: V) -> ClientBuilder
    method default_headers (line 737) | pub fn default_headers(mut self, headers: HeaderMap) -> ClientBuilder {
    method orig_headers (line 744) | pub fn orig_headers(mut self, orig_headers: OrigHeaderMap) -> ClientBu...
    method cookie_store (line 762) | pub fn cookie_store(mut self, enable: bool) -> ClientBuilder {
    method cookie_provider (line 784) | pub fn cookie_provider<C: cookie::IntoCookieStore>(mut self, cookie_st...
    method gzip (line 808) | pub fn gzip(mut self, enable: bool) -> ClientBuilder {
    method brotli (line 832) | pub fn brotli(mut self, enable: bool) -> ClientBuilder {
    method zstd (line 856) | pub fn zstd(mut self, enable: bool) -> ClientBuilder {
    method deflate (line 880) | pub fn deflate(mut self, enable: bool) -> ClientBuilder {
    method no_zstd (line 891) | pub fn no_zstd(self) -> ClientBuilder {
    method no_gzip (line 909) | pub fn no_gzip(self) -> ClientBuilder {
    method no_brotli (line 927) | pub fn no_brotli(self) -> ClientBuilder {
    method no_deflate (line 945) | pub fn no_deflate(self) -> ClientBuilder {
    method redirect (line 963) | pub fn redirect(mut self, policy: redirect::Policy) -> ClientBuilder {
    method referer (line 972) | pub fn referer(mut self, enable: bool) -> ClientBuilder {
    method retry (line 980) | pub fn retry(mut self, policy: retry::Policy) -> ClientBuilder {
    method proxy (line 1001) | pub fn proxy(mut self, proxy: Proxy) -> ClientBuilder {
    method no_proxy (line 1015) | pub fn no_proxy(mut self) -> ClientBuilder {
    method timeout (line 1030) | pub fn timeout(mut self, timeout: Duration) -> ClientBuilder {
    method read_timeout (line 1039) | pub fn read_timeout(mut self, timeout: Duration) -> ClientBuilder {
    method connect_timeout (line 1053) | pub fn connect_timeout(mut self, timeout: Duration) -> ClientBuilder {
    method connection_verbose (line 1065) | pub fn connection_verbose(mut self, verbose: bool) -> ClientBuilder {
    method pool_idle_timeout (line 1078) | pub fn pool_idle_timeout<D>(mut self, val: D) -> ClientBuilder
    method pool_max_idle_per_host (line 1088) | pub fn pool_max_idle_per_host(mut self, max: usize) -> ClientBuilder {
    method pool_max_size (line 1095) | pub fn pool_max_size(mut self, max: usize) -> ClientBuilder {
    method https_only (line 1104) | pub fn https_only(mut self, enabled: bool) -> ClientBuilder {
    method http1_only (line 1111) | pub fn http1_only(mut self) -> ClientBuilder {
    method http2_only (line 1118) | pub fn http2_only(mut self) -> ClientBuilder {
    method http1_options (line 1125) | pub fn http1_options<T>(mut self, options: T) -> ClientBuilder
    method http2_options (line 1135) | pub fn http2_options<T>(mut self, options: T) -> ClientBuilder
    method tcp_nodelay (line 1149) | pub fn tcp_nodelay(mut self, enabled: bool) -> ClientBuilder {
    method tcp_keepalive (line 1160) | pub fn tcp_keepalive<D>(mut self, val: D) -> ClientBuilder
    method tcp_keepalive_interval (line 1174) | pub fn tcp_keepalive_interval<D>(mut self, val: D) -> ClientBuilder
    method tcp_keepalive_retries (line 1188) | pub fn tcp_keepalive_retries<C>(mut self, retries: C) -> ClientBuilder
    method tcp_user_timeout (line 1210) | pub fn tcp_user_timeout<D>(mut self, val: D) -> ClientBuilder
    method tcp_reuse_address (line 1220) | pub fn tcp_reuse_address(mut self, enabled: bool) -> ClientBuilder {
    method tcp_send_buffer_size (line 1229) | pub fn tcp_send_buffer_size<S>(mut self, size: S) -> ClientBuilder
    method tcp_recv_buffer_size (line 1241) | pub fn tcp_recv_buffer_size<S>(mut self, size: S) -> ClientBuilder
    method tcp_happy_eyeballs_timeout (line 1262) | pub fn tcp_happy_eyeballs_timeout<D>(mut self, val: D) -> ClientBuilder
    method local_address (line 1283) | pub fn local_address<T>(mut self, addr: T) -> ClientBuilder
    method local_addresses (line 1308) | pub fn local_addresses<V4, V6>(mut self, ipv4: V4, ipv6: V6) -> Client...
    method interface (line 1379) | pub fn interface<T>(mut self, interface: T) -> ClientBuilder
    method tls_identity (line 1391) | pub fn tls_identity(mut self, identity: Identity) -> ClientBuilder {
    method tls_cert_store (line 1401) | pub fn tls_cert_store(mut self, store: CertStore) -> ClientBuilder {
    method tls_cert_verification (line 1418) | pub fn tls_cert_verification(mut self, cert_verification: bool) -> Cli...
    method tls_verify_hostname (line 1432) | pub fn tls_verify_hostname(mut self, verify_hostname: bool) -> ClientB...
    method tls_sni (line 1441) | pub fn tls_sni(mut self, tls_sni: bool) -> ClientBuilder {
    method tls_keylog (line 1448) | pub fn tls_keylog(mut self, keylog: KeyLog) -> ClientBuilder {
    method tls_min_version (line 1457) | pub fn tls_min_version(mut self, version: TlsVersion) -> ClientBuilder {
    method tls_max_version (line 1466) | pub fn tls_max_version(mut self, version: TlsVersion) -> ClientBuilder {
    method tls_info (line 1477) | pub fn tls_info(mut self, tls_info: bool) -> ClientBuilder {
    method tls_session_cache (line 1487) | pub fn tls_session_cache<S: IntoTlsSessionCache>(mut self, store: S) -...
    method tls_options (line 1494) | pub fn tls_options<T>(mut self, options: T) -> ClientBuilder
    method no_hickory_dns (line 1512) | pub fn no_hickory_dns(mut self) -> ClientBuilder {
    method resolve (line 1526) | pub fn resolve<D>(self, domain: D, addr: SocketAddr) -> ClientBuilder
    method resolve_to_addrs (line 1542) | pub fn resolve_to_addrs<D, A>(mut self, domain: D, addrs: A) -> Client...
    method dns_resolver (line 1559) | pub fn dns_resolver<R: IntoResolve>(mut self, resolver: R) -> ClientBu...
    method layer (line 1585) | pub fn layer<L>(mut self, layer: L) -> ClientBuilder
    method connector_layer (line 1622) | pub fn connector_layer<L>(mut self, layer: L) -> ClientBuilder
    method emulation (line 1647) | pub fn emulation<T: IntoEmulation>(self, emulation: T) -> ClientBuilder {
  type HttpVersionPref (line 188) | enum HttpVersionPref {
  type Config (line 194) | struct Config {
  method default (line 255) | fn default() -> Self {
  type Response (line 470) | type Response = Response;
  type Error (line 471) | type Error = Error;
  type Future (line 472) | type Future = Pending;
  function poll_ready (line 475) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self:...
  function call (line 480) | fn call(&mut self, req: Request) -> Self::Future {

FILE: src/client/body.rs
  type Body (line 17) | pub struct Body(Either<Full<Bytes>, BoxBody<Bytes, BoxError>>);
    method wrap (line 44) | pub fn wrap<B>(inner: B) -> Body
    method wrap_stream (line 76) | pub fn wrap_stream<S>(stream: S) -> Body
    method stream (line 86) | pub(crate) fn stream<S>(stream: S) -> Body
    method empty (line 107) | pub(crate) fn empty() -> Body {
    method reusable (line 112) | pub(crate) fn reusable(chunk: Bytes) -> Body {
    method content_length (line 118) | pub(crate) fn content_length(&self) -> Option<u64> {
    method try_clone (line 123) | pub(crate) fn try_clone(&self) -> Option<Body> {
    method from (line 140) | fn from(body: BoxBody<Bytes, BoxError>) -> Self {
    method from (line 147) | fn from(bytes: Bytes) -> Body {
    method from (line 154) | fn from(vec: Vec<u8>) -> Body {
    method from (line 161) | fn from(s: &'static [u8]) -> Body {
    method from (line 168) | fn from(s: String) -> Body {
    method from (line 175) | fn from(s: &'static str) -> Body {
    method from (line 183) | fn from(file: File) -> Body {
  method default (line 133) | fn default() -> Body {
  type Data (line 189) | type Data = Bytes;
  type Error (line 190) | type Error = Error;
  method poll_frame (line 193) | fn poll_frame(
  method size_hint (line 204) | fn size_hint(&self) -> SizeHint {
  method is_end_stream (line 209) | fn is_end_stream(&self) -> bool {
  type Data (line 221) | type Data = Bytes;
  type Error (line 222) | type Error = B::Error;
  method poll_frame (line 224) | fn poll_frame(
  method size_hint (line 236) | fn size_hint(&self) -> SizeHint {
  method is_end_stream (line 241) | fn is_end_stream(&self) -> bool {
  function body_exact_length (line 253) | fn body_exact_length() {

FILE: src/client/conn.rs
  type HttpConnector (line 45) | pub type HttpConnector = self::http::HttpConnector<DynResolver, TokioTcp...
  type BoxedConnectorService (line 48) | pub type BoxedConnectorService = BoxCloneSyncService<Unnameable, Conn, B...
  type BoxedConnectorLayer (line 51) | pub type BoxedConnectorLayer =
  type Unnameable (line 59) | pub struct Unnameable(pub(super) descriptor::ConnectionDescriptor);
  type AsyncConn (line 67) | trait AsyncConn: AsyncRead + AsyncWrite + Connection + Send + Sync + Unp...
  type AsyncConnWithInfo (line 73) | trait AsyncConnWithInfo: AsyncConn + TlsInfoFactory {}
  type Connection (line 105) | pub trait Connection {
    method connected (line 107) | fn connected(&self) -> Connected;
    method connected (line 165) | fn connected(&self) -> Connected {
    method connected (line 236) | fn connected(&self) -> Connected {
  type Alpn (line 112) | enum Alpn {
  type PoisonPill (line 119) | struct PoisonPill(Arc<AtomicBool>);
    method fmt (line 305) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
    method healthy (line 319) | fn healthy() -> Self {
  type Extra (line 123) | struct Extra(Box<dyn ExtraInner>);
    method set (line 424) | fn set(&self, res: &mut Extensions) {
  type ExtraInner (line 126) | trait ExtraInner: Send + Sync + Debug {
    method clone_box (line 127) | fn clone_box(&self) -> Box<dyn ExtraInner>;
    method set (line 128) | fn set(&self, res: &mut Extensions);
    method clone_box (line 441) | fn clone_box(&self) -> Box<dyn ExtraInner> {
    method set (line 445) | fn set(&self, res: &mut Extensions) {
    method clone_box (line 462) | fn clone_box(&self) -> Box<dyn ExtraInner> {
    method set (line 466) | fn set(&self, res: &mut Extensions) {
  type ExtraEnvelope (line 135) | struct ExtraEnvelope<T>(T);
  type ExtraChain (line 140) | struct ExtraChain<T>(Box<dyn ExtraInner>, T);
  type ProxyIdentity (line 144) | struct ProxyIdentity {
  type Connected (line 155) | pub struct Connected {
    method new (line 328) | pub fn new() -> Connected {
    method extra (line 338) | pub fn extra<T: Clone + Send + Sync + Debug + 'static>(mut self, extra...
    method set_extras (line 349) | pub fn set_extras(&self, extensions: &mut Extensions) {
    method proxy (line 356) | pub fn proxy(mut self, proxy: Intercept) -> Connected {
    method is_proxied (line 372) | pub fn is_proxied(&self) -> bool {
    method proxy_auth (line 378) | pub fn proxy_auth(&self) -> Option<&HeaderValue> {
    method proxy_headers (line 384) | pub fn proxy_headers(&self) -> Option<&HeaderMap> {
    method negotiated_h2 (line 390) | pub fn negotiated_h2(mut self) -> Connected {
    method is_negotiated_h2 (line 397) | pub fn is_negotiated_h2(&self) -> bool {
    method poisoned (line 403) | pub fn poisoned(&self) -> bool {
    method poison (line 412) | pub fn poison(&self) {
  method poll_read (line 186) | fn poll_read(
  method poll_write (line 197) | fn poll_write(
  method poll_write_vectored (line 206) | fn poll_write_vectored(
  method is_write_vectored (line 215) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 220) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(),...
  method poll_shutdown (line 225) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<...
  method poll_read (line 248) | fn poll_read(
  method poll_write (line 259) | fn poll_write(
  method poll_write_vectored (line 268) | fn poll_write_vectored(
  method is_write_vectored (line 277) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 282) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(),...
  method poll_shutdown (line 287) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<...
  method tls_info (line 297) | fn tls_info(&self) -> Option<TlsInfo> {
  method clone (line 430) | fn clone(&self) -> Extra {
  method clone (line 453) | fn clone(&self) -> Self {

FILE: src/client/conn/connector.rs
  type Connecting (line 37) | type Connecting = Pin<Box<dyn Future<Output = Result<Conn, BoxError>> + ...
  type Config (line 41) | struct Config {
  type ConnectorBuilder (line 54) | pub struct ConnectorBuilder {
    method with_http (line 85) | pub fn with_http<F>(mut self, call: F) -> ConnectorBuilder
    method with_tls (line 95) | pub fn with_tls<F>(mut self, call: F) -> ConnectorBuilder
    method timeout (line 108) | pub fn timeout(mut self, timeout: Option<Duration>) -> ConnectorBuilder {
    method verbose (line 115) | pub fn verbose(mut self, enabled: bool) -> ConnectorBuilder {
    method tls_info (line 122) | pub fn tls_info(mut self, enabled: bool) -> ConnectorBuilder {
    method tcp_nodelay (line 129) | pub fn tcp_nodelay(mut self, enabled: bool) -> ConnectorBuilder {
    method build (line 135) | pub fn build(
  type Connector (line 64) | pub enum Connector {
    method builder (line 202) | pub(crate) fn builder(proxies: Vec<ProxyMatcher>, resolver: DynResolve...
    type Response (line 220) | type Response = Conn;
    type Error (line 221) | type Error = BoxError;
    type Future (line 222) | type Future = Connecting;
    method poll_ready (line 225) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self...
    method call (line 233) | fn call(&mut self, descriptor: ConnectionDescriptor) -> Self::Future {
  type ConnectorService (line 71) | pub struct ConnectorService {
    method build_https_connector (line 244) | fn build_https_connector(
    method tunnel_conn_from_stream (line 288) | fn tunnel_conn_from_stream<IO>(&self, io: MaybeHttpsStream<IO>) -> Res...
    method conn_from_stream (line 310) | fn conn_from_stream<IO, P>(&self, io: MaybeHttpsStream<IO>, proxy: P) ...
    method connect_auto_proxy (line 329) | async fn connect_auto_proxy<P: Into<Option<Intercept>>>(
    method connect_via_proxy (line 356) | async fn connect_via_proxy(
    method connect_auto (line 496) | async fn connect_auto(self, req: ConnectionDescriptor) -> Result<Conn,...
    type Response (line 531) | type Response = Conn;
    type Error (line 532) | type Error = BoxError;
    type Future (line 533) | type Future = Connecting;
    method poll_ready (line 536) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Sel...
    method call (line 541) | fn call(&mut self, descriptor: ConnectionDescriptor) -> Self::Future {

FILE: src/client/conn/descriptor.rs
  type ConnectionId (line 25) | pub(crate) struct ConnectionId(Arc<(Group, AtomicU64)>);
  type ConnectionDescriptor (line 33) | pub(crate) struct ConnectionDescriptor {
    method new (line 80) | pub(crate) fn new(
    method id (line 109) | pub(crate) fn id(&self) -> ConnectionId {
    method uri (line 115) | pub(crate) fn uri(&self) -> &Uri {
    method uri_mut (line 121) | pub(crate) fn uri_mut(&mut self) -> &mut Uri {
    method version (line 126) | pub(crate) fn version(&self) -> Option<Version> {
    method tls_options (line 132) | pub(crate) fn tls_options(&self) -> Option<&TlsOptions> {
    method proxy (line 138) | pub(crate) fn proxy(&self) -> Option<&ProxyMacher> {
    method socket_bind_options (line 144) | pub(crate) fn socket_bind_options(&self) -> Option<&SocketBindOptions> {
  method hash (line 45) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 69) | fn eq(&self, other: &Self) -> bool {

FILE: src/client/conn/http.rs
  type ConnectResult (line 29) | type ConnectResult<S> = Result<<S as TcpConnector>::Connection, ConnectE...
  type BoxConnecting (line 30) | type BoxConnecting<S> = Pin<Box<dyn Future<Output = ConnectResult<S>> + ...
  type HttpTransport (line 37) | pub trait HttpTransport: Service<Uri> + Clone + Send + Sized + 'static
    method enforce_http (line 45) | fn enforce_http(&mut self, enforced: bool);
    method set_nodelay (line 48) | fn set_nodelay(&mut self, nodelay: bool);
    method set_send_buffer_size (line 51) | fn set_send_buffer_size(&mut self, size: Option<usize>);
    method set_recv_buffer_size (line 54) | fn set_recv_buffer_size(&mut self, size: Option<usize>);
    method set_reuse_address (line 57) | fn set_reuse_address(&mut self, reuse: bool);
    method set_tcp_user_timeout (line 61) | fn set_tcp_user_timeout(&mut self, time: Option<Duration>);
    method set_connect_timeout (line 64) | fn set_connect_timeout(&mut self, dur: Option<Duration>);
    method set_happy_eyeballs_timeout (line 69) | fn set_happy_eyeballs_timeout(&mut self, dur: Option<Duration>);
    method set_keepalive (line 73) | fn set_keepalive(&mut self, time: Option<Duration>);
    method set_keepalive_interval (line 77) | fn set_keepalive_interval(&mut self, interval: Option<Duration>);
    method set_keepalive_retries (line 81) | fn set_keepalive_retries(&mut self, retries: Option<u32>);
    method set_interface (line 96) | fn set_interface<I: Into<std::borrow::Cow<'static, str>>>(&mut self, i...
    method set_local_addresses (line 100) | fn set_local_addresses<V4, V6>(&mut self, ipv4_address: V4, ipv6_addre...
    method enforce_http (line 189) | fn enforce_http(&mut self, is_enforced: bool) {
    method set_nodelay (line 197) | fn set_nodelay(&mut self, nodelay: bool) {
    method set_send_buffer_size (line 203) | fn set_send_buffer_size(&mut self, size: Option<usize>) {
    method set_recv_buffer_size (line 209) | fn set_recv_buffer_size(&mut self, size: Option<usize>) {
    method set_reuse_address (line 217) | fn set_reuse_address(&mut self, reuse_address: bool) {
    method set_tcp_user_timeout (line 224) | fn set_tcp_user_timeout(&mut self, time: Option<Duration>) {
    method set_connect_timeout (line 235) | fn set_connect_timeout(&mut self, dur: Option<Duration>) {
    method set_happy_eyeballs_timeout (line 252) | fn set_happy_eyeballs_timeout(&mut self, dur: Option<Duration>) {
    method set_keepalive (line 263) | fn set_keepalive(&mut self, time: Option<Duration>) {
    method set_keepalive_interval (line 270) | fn set_keepalive_interval(&mut self, interval: Option<Duration>) {
    method set_keepalive_retries (line 277) | fn set_keepalive_retries(&mut self, retries: Option<u32>) {
    method set_interface (line 317) | fn set_interface<I: Into<std::borrow::Cow<'static, str>>>(&mut self, i...
    method set_local_addresses (line 327) | fn set_local_addresses<V4, V6>(&mut self, ipv4_address: V4, ipv6_addre...
  type HttpConnector (line 115) | pub struct HttpConnector<R, S> {
  type HttpInfo (line 142) | pub struct HttpInfo {
    method remote_addr (line 449) | pub fn remote_addr(&self) -> SocketAddr {
    method local_addr (line 454) | pub fn local_addr(&self) -> SocketAddr {
  function new (line 151) | pub fn new(resolver: R, connector: S) -> HttpConnector<R, S> {
  function config_mut (line 171) | fn config_mut(&mut self) -> &mut TcpOptions {
  type Response (line 345) | type Response = S::Connection;
  type Error (line 346) | type Error = ConnectError;
  type Future (line 347) | type Future = HttpConnecting<R, S>;
    type Output (line 478) | type Output = ConnectResult<S>;
    method poll (line 481) | fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self...
  function poll_ready (line 350) | fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), ...
  function call (line 354) | fn call(&mut self, dst: Uri) -> Self::Future {
  function get_host_port (line 390) | fn get_host_port<'u>(options: &TcpOptions, dst: &'u Uri) -> Result<(&'u ...
  function set_port (line 441) | fn set_port(addr: &mut SocketAddr, host_port: u16, explicit: bool) {

FILE: src/client/conn/proxy.rs
  type Output (line 33) | type Output = Result<T, E2>;
  method poll (line 36) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: src/client/conn/proxy/socks.rs
  type SocksError (line 23) | pub enum SocksError {
    method fmt (line 34) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method from (line 58) | fn from(err: std::io::Error) -> Self {
    method from (line 64) | fn from(err: std::str::Utf8Error) -> Self {
    method from (line 70) | fn from(err: tokio_socks::Error) -> Self {
  type Version (line 78) | pub enum Version {
  type DnsResolve (line 86) | pub enum DnsResolve {
  type SocksConnector (line 92) | pub struct SocksConnector<C, R = GaiResolver> {
  function new (line 106) | pub fn new(proxy_dst: Uri, inner: C, resolver: R) -> Self {
  function set_auth (line 119) | pub fn set_auth(&mut self, auth: Option<(Bytes, Bytes)>) {
  function set_version (line 125) | pub fn set_version(&mut self, version: Version) {
  function set_dns_mode (line 131) | pub fn set_dns_mode(&mut self, dns_resolve: DnsResolve) {
  type Response (line 145) | type Response = C::Response;
  type Error (line 146) | type Error = SocksError;
  type Future (line 147) | type Future = Tunneling<C::Future, C::Response, Self::Error>;
  function poll_ready (line 150) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 157) | fn call(&mut self, dst: Uri) -> Self::Future {

FILE: src/client/conn/proxy/tunnel.rs
  type TunnelConnector (line 20) | pub struct TunnelConnector<C> {
  type Headers (line 27) | enum Headers {
  type TunnelError (line 34) | pub enum TunnelError {
    method fmt (line 201) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method source (line 217) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
  function new (line 53) | pub fn new(proxy_dst: Uri, connector: C) -> Self {
  function with_auth (line 62) | pub fn with_auth(mut self, mut auth: HeaderValue) -> Self {
  function with_headers (line 83) | pub fn with_headers(mut self, mut headers: HeaderMap) -> Self {
  type Response (line 110) | type Response = C::Response;
  type Error (line 111) | type Error = TunnelError;
  type Future (line 112) | type Future = Tunneling<C::Future, C::Response, Self::Error>;
  function poll_ready (line 115) | fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), ...
  function call (line 122) | fn call(&mut self, dst: Uri) -> Self::Future {
  function tunnel (line 145) | async fn tunnel<T>(mut conn: T, host: &str, port: u16, headers: &Headers...

FILE: src/client/conn/tcp.rs
  type TcpConnector (line 33) | pub trait TcpConnector: Clone + Send + Sync + 'static {
    method connect (line 55) | fn connect(&self, socket: Self::TcpStream, addr: SocketAddr) -> Self::...
    method sleep (line 58) | fn sleep(&self, duration: Duration) -> Self::Sleep;
  type ConnectingTcp (line 61) | pub(super) struct ConnectingTcp<S: TcpConnector> {
  type ConnectingTcpFallback (line 66) | struct ConnectingTcpFallback<S: TcpConnector> {
  type ConnectingTcpRemote (line 71) | struct ConnectingTcpRemote<S: TcpConnector> {
  function new (line 81) | pub(super) fn new(remote_addrs: dns::SocketAddrs, config: &TcpOptions, c...
  function new (line 130) | fn new(addrs: dns::SocketAddrs, connect_timeout: Option<Duration>, conne...
  function connect (line 140) | async fn connect(&mut self, config: &TcpOptions) -> Result<S::Connection...
  function bind_local_address (line 178) | fn bind_local_address(
  function connect (line 206) | fn connect<S: TcpConnector>(
  function connect (line 347) | pub(super) async fn connect(
  type ConnectError (line 384) | pub struct ConnectError {
    method new (line 391) | pub(super) fn new<E>(msg: &'static str, cause: E) -> ConnectError
    method dns (line 402) | pub(super) fn dns<E>(cause: E) -> ConnectError
    method m (line 409) | pub(super) fn m<E>(msg: &'static str) -> impl FnOnce(E) -> ConnectError
    method fmt (line 418) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 432) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 438) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type SocketBindOptions (line 445) | pub(crate) struct SocketBindOptions {
    method set_interface (line 494) | pub fn set_interface<I>(&mut self, interface: I) -> &mut Self
    method set_local_address (line 508) | pub fn set_local_address<V>(&mut self, local_address: V)
    method set_local_addresses (line 530) | pub fn set_local_addresses<V4, V6>(&mut self, ipv4_address: V4, ipv6_a...
  type TcpOptions (line 545) | pub(crate) struct TcpOptions {
  type TcpKeepaliveOptions (line 560) | pub(crate) struct TcpKeepaliveOptions {
    method into_tcpkeepalive (line 600) | pub(crate) fn into_tcpkeepalive(self) -> Option<TcpKeepalive> {

FILE: src/client/conn/tcp/tokio.rs
  type TokioTcpConnector (line 10) | pub struct TokioTcpConnector {
    method new (line 16) | pub fn new() -> Self {
  type TcpStream (line 22) | type TcpStream = std::net::TcpStream;
  type Connection (line 23) | type Connection = TcpStream;
  type Error (line 24) | type Error = io::Error;
  type Future (line 25) | type Future = Pin<Box<dyn Future<Output = Result<Self::Connection, Self:...
  type Sleep (line 26) | type Sleep = tokio::time::Sleep;
  method connect (line 29) | fn connect(&self, socket: Self::TcpStream, addr: SocketAddr) -> Self::Fu...
  method sleep (line 35) | fn sleep(&self, duration: Duration) -> Self::Sleep {
  method connected (line 41) | fn connected(&self) -> Connected {

FILE: src/client/conn/tls_info.rs
  type TlsInfoFactory (line 13) | pub trait TlsInfoFactory {
    method tls_info (line 14) | fn tls_info(&self) -> Option<TlsInfo>;
    method tls_info (line 37) | fn tls_info(&self) -> Option<TlsInfo> {
    method tls_info (line 44) | fn tls_info(&self) -> Option<TlsInfo> {
    method tls_info (line 50) | fn tls_info(&self) -> Option<TlsInfo> {
    method tls_info (line 60) | fn tls_info(&self) -> Option<TlsInfo> {
    method tls_info (line 69) | fn tls_info(&self) -> Option<TlsInfo> {
    method tls_info (line 77) | fn tls_info(&self) -> Option<TlsInfo> {
    method tls_info (line 84) | fn tls_info(&self) -> Option<TlsInfo> {
    method tls_info (line 95) | fn tls_info(&self) -> Option<TlsInfo> {
  function extract_tls_info (line 17) | fn extract_tls_info<S>(ssl_stream: &SslStream<S>) -> TlsInfo {

FILE: src/client/conn/uds.rs
  type ConnectResult (line 14) | type ConnectResult = io::Result<UnixStream>;
  type BoxConnecting (line 15) | type BoxConnecting = Pin<Box<dyn Future<Output = ConnectResult> + Send>>;
  type UnixConnector (line 18) | pub struct UnixConnector {
    method new (line 24) | pub fn new(path: impl Into<Arc<Path>>) -> Self {
    type Response (line 30) | type Response = UnixStream;
    type Error (line 31) | type Error = io::Error;
    type Future (line 32) | type Future = BoxConnecting;
    method poll_ready (line 35) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Sel...
    method call (line 39) | fn call(&mut self, _: Uri) -> Self::Future {
  method connected (line 50) | fn connected(&self) -> Connected {

FILE: src/client/conn/verbose.rs
  type Verbose (line 8) | pub struct Verbose(pub(super) bool);
    constant OFF (line 11) | pub const OFF: Verbose = Verbose(false);
    method wrap (line 14) | pub(super) fn wrap<T>(&self, conn: T) -> Box<dyn AsyncConnWithInfo>
  type Wrapper (line 44) | pub(super) struct Wrapper<T> {
  method connected (line 51) | fn connected(&self) -> Connected {
  method poll_read (line 57) | fn poll_read(
  method poll_write (line 74) | fn poll_write(
  method poll_write_vectored (line 89) | fn poll_write_vectored(
  method is_write_vectored (line 109) | fn is_write_vectored(&self) -> bool {
  method poll_flush (line 114) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Re...
  method poll_shutdown (line 119) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io:...
  method tls_info (line 125) | fn tls_info(&self) -> Option<TlsInfo> {
  type Vectored (line 130) | struct Vectored<'a, 'b> {
  function fmt (line 136) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: src/client/core/body.rs
  function _assert_send_sync (line 29) | fn _assert_send_sync() {

FILE: src/client/core/body/incoming.rs
  type Incoming (line 21) | pub struct Incoming {
    method empty (line 66) | pub(crate) fn empty() -> Incoming {
    method h1 (line 70) | pub(crate) fn h1(content_length: DecodedLength, wanter: bool) -> (Send...
    method h2 (line 95) | pub(crate) fn h2(
    method fmt (line 232) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method channel (line 311) | pub(crate) fn channel() -> (Sender, Incoming) {
  type Kind (line 25) | enum Kind {
  type Sender (line 56) | pub(crate) struct Sender {
    method poll_ready (line 247) | pub(crate) fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Resu...
    method send_data (line 267) | pub(crate) fn send_data(&mut self, chunk: Bytes) -> Result<(), Bytes> {
    method send_trailers (line 282) | pub(crate) fn send_trailers(&mut self, trailers: HeaderMap) -> Result<...
    method send_error (line 292) | pub(crate) fn send_error(&mut self, err: Error) {
    method ready (line 317) | async fn ready(&mut self) -> Result<()> {
    method abort (line 321) | fn abort(mut self) {
  type Data (line 118) | type Data = Bytes;
  type Error (line 119) | type Error = Error;
  method poll_frame (line 121) | fn poll_frame(
  method is_end_stream (line 212) | fn is_end_stream(&self) -> bool {
  method size_hint (line 221) | fn size_hint(&self) -> SizeHint {
  function test_size_of (line 327) | fn test_size_of() {
  function size_hint (line 354) | fn size_hint() {
  function channel_abort (line 373) | async fn channel_abort() {
  function channel_abort_when_buffer_is_full (line 383) | async fn channel_abort_when_buffer_is_full() {
  function channel_buffers_two (line 405) | async fn channel_buffers_two() {
  function channel_empty (line 424) | async fn channel_empty() {
  function channel_ready (line 430) | fn channel_ready() {
  function channel_wanter (line 439) | fn channel_wanter() {
  function channel_notices_closure (line 460) | fn channel_notices_closure() {

FILE: src/client/core/body/length.rs
  type DecodedLength (line 6) | pub(crate) struct DecodedLength(u64);
    constant MAX_LEN (line 9) | pub(crate) const MAX_LEN: u64 = u64::MAX - 2;
    constant CLOSE_DELIMITED (line 10) | pub(crate) const CLOSE_DELIMITED: DecodedLength = DecodedLength(u64::M...
    constant CHUNKED (line 11) | pub(crate) const CHUNKED: DecodedLength = DecodedLength(u64::MAX - 1);
    constant ZERO (line 12) | pub(crate) const ZERO: DecodedLength = DecodedLength(0);
    method danger_len (line 19) | pub(crate) fn danger_len(self) -> u64 {
    method into_opt (line 26) | pub(crate) fn into_opt(self) -> Option<u64> {
    method checked_new (line 34) | pub(crate) fn checked_new(len: u64) -> Result<Self, Parse> {
    method sub_if (line 48) | pub(crate) fn sub_if(&mut self, amt: u64) {
    method is_exact (line 63) | pub(crate) fn is_exact(&self) -> bool {
    method from (line 69) | fn from(len: Option<u64>) -> Self {
    method fmt (line 77) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 87) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 102) | pub(crate) fn new(len: u64) -> Self {
  function sub_if_known (line 109) | fn sub_if_known() {
  function sub_if_chunked (line 117) | fn sub_if_chunked() {

FILE: src/client/core/body/watch.rs
  type Value (line 19) | type Value = u8;
  constant READY (line 20) | const READY: Value = 2;
  constant PENDING (line 21) | const PENDING: Value = 1;
  constant CLOSED (line 22) | const CLOSED: Value = 0;
  function channel (line 24) | pub(super) fn channel(wanter: bool) -> (Sender, Receiver) {
  type Shared (line 39) | struct Shared {
  type Sender (line 44) | pub(super) struct Sender {
    method ready (line 56) | pub(super) fn ready(&self) {
    method send (line 60) | fn send(&self, value: Value) {
  type Receiver (line 48) | pub(super) struct Receiver {
    method poll_ready (line 78) | pub(super) fn poll_ready(&self, cx: &mut task::Context<'_>) -> Poll<Re...
  method drop (line 69) | fn drop(&mut self) {

FILE: src/client/core/conn/http1.rs
  type SendRequest (line 27) | pub struct SendRequest<B> {
  type Parts (line 37) | pub struct Parts<T> {
  type Connection (line 56) | pub struct Connection<T, B>
  function into_parts (line 74) | pub fn into_parts(self) -> Parts<T> {
  type Builder (line 87) | pub struct Builder {
    method new (line 203) | pub fn new() -> Builder {
    method options (line 211) | pub fn options(&mut self, opts: Http1Options) {
    method handshake (line 219) | pub async fn handshake<T, B>(self, io: T) -> Result<(SendRequest<B>, C...
  function poll_ready (line 98) | pub fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>> {
  function ready (line 106) | pub async fn ready(&mut self) -> Result<()> {
  function is_ready (line 118) | pub fn is_ready(&self) -> bool {
  function try_send_request (line 135) | pub fn try_send_request(
  function with_upgrades (line 169) | pub fn with_upgrades(self) -> upgrades::UpgradeableConnection<T, B> {
  type Output (line 181) | type Output = Result<()>;
  method poll (line 183) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type UpgradeableConnection (line 290) | pub struct UpgradeableConnection<T, B>
  type Output (line 306) | type Output = Result<()>;
  method poll (line 308) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/client/core/conn/http2.rs
  type SendRequest (line 28) | pub struct SendRequest<B> {
  method clone (line 34) | fn clone(&self) -> SendRequest<B> {
  type Connection (line 46) | pub struct Connection<T, B, E>
  type Builder (line 63) | pub struct Builder<Ex> {
  function poll_ready (line 76) | pub fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<()>> {
  function ready (line 88) | pub async fn ready(&mut self) -> Result<()> {
  function is_ready (line 100) | pub fn is_ready(&self) -> bool {
  function is_closed (line 106) | pub fn is_closed(&self) -> bool {
  function try_send_request (line 123) | pub fn try_send_request(
  type Output (line 160) | type Output = Result<()>;
  method poll (line 163) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  function new (line 179) | pub fn new(exec: Ex) -> Builder<Ex> {
  function timer (line 189) | pub fn timer<M>(&mut self, timer: M)
  function options (line 198) | pub fn options(&mut self, opts: Http2Options) {
  function handshake (line 206) | pub async fn handshake<T, B>(self, io: T) -> Result<(SendRequest<B>, Con...

FILE: src/client/core/dispatch.rs
  type RetryPromise (line 14) | type RetryPromise<T, U> = oneshot::Receiver<Result<U, TrySendError<T>>>;
  function channel (line 16) | pub(crate) fn channel<T, U>() -> (Sender<T, U>, Receiver<T, U>) {
  type TrySendError (line 36) | pub struct TrySendError<T> {
  type Sender (line 45) | pub(crate) struct Sender<T, U> {
  type UnboundedSender (line 63) | pub(crate) struct UnboundedSender<T, U> {
  function poll_ready (line 71) | pub(crate) fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<super:...
  function is_ready (line 76) | pub(crate) fn is_ready(&self) -> bool {
  function try_send (line 80) | pub(crate) fn try_send(&mut self, val: T) -> Result<RetryPromise<T, U>, ...
  function unbound (line 99) | pub(crate) fn unbound(self) -> UnboundedSender<T, U> {
  function is_ready (line 109) | pub(crate) fn is_ready(&self) -> bool {
  function is_closed (line 114) | pub(crate) fn is_closed(&self) -> bool {
  function try_send (line 118) | pub(crate) fn try_send(&mut self, val: T) -> Result<RetryPromise<T, U>, ...
  method clone (line 129) | fn clone(&self) -> Self {
  type Receiver (line 137) | pub(crate) struct Receiver<T, U> {
  function poll_recv (line 143) | pub(crate) fn poll_recv(&mut self, cx: &mut Context<'_>) -> Poll<Option<...
  function close (line 156) | pub(crate) fn close(&mut self) {
  function try_recv (line 162) | pub(crate) fn try_recv(&mut self) -> Option<(T, Callback<T, U>)> {
  method drop (line 173) | fn drop(&mut self) {
  type Envelope (line 180) | struct Envelope<T, U>(Option<(T, Callback<T, U>)>);
  method drop (line 183) | fn drop(&mut self) {
  type Callback (line 193) | pub(crate) struct Callback<T, U>(Option<oneshot::Sender<Result<U, TrySen...
  method drop (line 196) | fn drop(&mut self) {
  function dispatch_gone (line 207) | fn dispatch_gone() -> Error {
  constant MISSING_SENDER (line 217) | const MISSING_SENDER: &'static str = "callback sender missing";
  function is_canceled (line 220) | pub(crate) fn is_canceled(&self) -> bool {
  function poll_canceled (line 225) | pub(crate) fn poll_canceled(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function send (line 230) | pub(crate) fn send(mut self, val: Result<U, TrySendError<T>>) {
  function take_message (line 242) | pub fn take_message(&mut self) -> Option<T> {
  function into_error (line 248) | pub fn into_error(self) -> Error {
  type Output (line 271) | type Output = ();
  method poll (line 273) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: src/client/core/error.rs
  type Result (line 5) | pub type Result<T, E = Error> = std::result::Result<T, E>;
  type BoxError (line 7) | pub type BoxError = Box<dyn StdError + Send + Sync>;
  type Cause (line 9) | type Cause = BoxError;
  type Error (line 32) | pub struct Error {
    method is_parse (line 109) | pub fn is_parse(&self) -> bool {
    method is_parse_status (line 116) | pub fn is_parse_status(&self) -> bool {
    method is_user (line 122) | pub fn is_user(&self) -> bool {
    method is_canceled (line 128) | pub fn is_canceled(&self) -> bool {
    method is_closed (line 134) | pub fn is_closed(&self) -> bool {
    method is_incomplete_message (line 140) | pub fn is_incomplete_message(&self) -> bool {
    method is_body_write_aborted (line 146) | pub fn is_body_write_aborted(&self) -> bool {
    method is_timeout (line 152) | pub fn is_timeout(&self) -> bool {
    method new (line 157) | pub(super) fn new(kind: Kind) -> Error {
    method with (line 164) | pub(super) fn with<C: Into<Cause>>(mut self, cause: C) -> Error {
    method find_source (line 169) | pub(crate) fn find_source<E: StdError + 'static>(&self) -> Option<&E> {
    method h2_reason (line 182) | pub(super) fn h2_reason(&self) -> http2::Reason {
    method new_canceled (line 191) | pub(super) fn new_canceled() -> Error {
    method new_incomplete (line 196) | pub(super) fn new_incomplete() -> Error {
    method new_too_large (line 201) | pub(super) fn new_too_large() -> Error {
    method new_version_h2 (line 206) | pub(super) fn new_version_h2() -> Error {
    method new_unexpected_message (line 211) | pub(super) fn new_unexpected_message() -> Error {
    method new_io (line 216) | pub(super) fn new_io(cause: std::io::Error) -> Error {
    method new_closed (line 221) | pub(super) fn new_closed() -> Error {
    method new_body (line 226) | pub(super) fn new_body<E: Into<Cause>>(cause: E) -> Error {
    method new_body_write (line 231) | pub(super) fn new_body_write<E: Into<Cause>>(cause: E) -> Error {
    method new_body_write_aborted (line 236) | pub(super) fn new_body_write_aborted() -> Error {
    method new_user (line 241) | fn new_user(user: User) -> Error {
    method new_user_no_upgrade (line 246) | pub(super) fn new_user_no_upgrade() -> Error {
    method new_user_manual_upgrade (line 251) | pub(super) fn new_user_manual_upgrade() -> Error {
    method new_user_service (line 256) | pub(super) fn new_user_service<E: Into<Cause>>(cause: E) -> Error {
    method new_user_body (line 261) | pub(super) fn new_user_body<E: Into<Cause>>(cause: E) -> Error {
    method new_user_invalid_connect (line 266) | pub(super) fn new_user_invalid_connect() -> Error {
    method new_shutdown (line 271) | pub(super) fn new_shutdown(cause: std::io::Error) -> Error {
    method new_user_dispatch_gone (line 276) | pub(super) fn new_user_dispatch_gone() -> Error {
    method new_h2 (line 280) | pub(super) fn new_h2(cause: ::http2::Error) -> Error {
    method description (line 288) | fn description(&self) -> &str {
    method fmt (line 331) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 342) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 358) | fn from(err: Parse) -> Error {
  type ErrorImpl (line 36) | struct ErrorImpl {
  type Kind (line 42) | pub(super) enum Kind {
  type Parse (line 66) | pub(crate) enum Parse {
    method content_length_invalid (line 365) | pub(crate) fn content_length_invalid() -> Self {
    method transfer_encoding_unexpected (line 370) | pub(crate) fn transfer_encoding_unexpected() -> Self {
    method from (line 376) | fn from(err: httparse::Error) -> Parse {
    method from (line 390) | fn from(_: http::method::InvalidMethod) -> Parse {
    method from (line 396) | fn from(_: http::status::InvalidStatusCode) -> Parse {
    method from (line 402) | fn from(_: http::uri::InvalidUri) -> Parse {
    method from (line 408) | fn from(_: http::uri::InvalidUriParts) -> Parse {
  type Header (line 78) | pub(crate) enum Header {
  type User (line 85) | pub(super) enum User {
  type TimedOut (line 104) | pub(super) struct TimedOut;
    method fmt (line 416) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method source (line 348) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  function assert_send_sync (line 429) | fn assert_send_sync<T: Send + Sync + 'static>() {}
  function error_satisfies_send_sync (line 432) | fn error_satisfies_send_sync() {
  function error_size_of (line 437) | fn error_size_of() {
  function h2_reason_unknown (line 442) | fn h2_reason_unknown() {
  function h2_reason_one_level (line 448) | fn h2_reason_one_level() {
  function h2_reason_nested (line 454) | fn h2_reason_nested() {

FILE: src/client/core/proto.rs
  type RequestLine (line 10) | pub(crate) struct RequestLine(http::Method, http::Uri);
  type MessageHead (line 14) | pub(crate) struct MessageHead<S> {
  type RequestHead (line 26) | type RequestHead = MessageHead<RequestLine>;
  type ResponseHead (line 29) | type ResponseHead = MessageHead<http::StatusCode>;
  type BodyLength (line 32) | pub(crate) enum BodyLength {
  type Dispatched (line 40) | pub(crate) enum Dispatched {
  function into_response (line 48) | fn into_response<B>(self, body: B) -> http::Response<B> {

FILE: src/client/core/proto/headers.rs
  function connection_keep_alive (line 8) | pub(super) fn connection_keep_alive(value: &HeaderValue) -> bool {
  function connection_close (line 13) | pub(super) fn connection_close(value: &HeaderValue) -> bool {
  function connection_has (line 17) | fn connection_has(value: &HeaderValue, needle: &str) -> bool {
  function content_length_parse_all (line 29) | pub(super) fn content_length_parse_all(headers: &HeaderMap) -> Option<u6...
  function content_length_parse_all_values (line 33) | pub(super) fn content_length_parse_all_values(values: ValueIter<'_, Head...
  function from_digits (line 60) | fn from_digits(bytes: &[u8]) -> Option<u64> {
  function method_has_defined_payload_semantics (line 88) | pub(super) fn method_has_defined_payload_semantics(method: &Method) -> b...
  function set_content_length_if_missing (line 96) | pub(super) fn set_content_length_if_missing(headers: &mut HeaderMap, len...
  function transfer_encoding_is_chunked (line 103) | pub(super) fn transfer_encoding_is_chunked(headers: &HeaderMap) -> bool {
  function is_chunked (line 107) | pub(super) fn is_chunked(mut encodings: ValueIter<'_, HeaderValue>) -> b...
  function add_chunked (line 121) | pub(super) fn add_chunked(mut entry: http::header::OccupiedEntry<'_, Hea...

FILE: src/client/core/proto/http1.rs
  type Http1Transaction (line 24) | pub(crate) trait Http1Transaction {
    constant LOG (line 30) | const LOG: &'static str;
    method parse (line 32) | fn parse(
    method encode (line 37) | fn encode(enc: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> Resul...
    method on_error (line 39) | fn on_error(err: &Error) -> Option<MessageHead<Self::Outgoing>>;
    method update_date (line 41) | fn update_date() {}
  type ParsedMessage (line 45) | pub(crate) struct ParsedMessage<T> {
  type ParseContext (line 53) | pub(crate) struct ParseContext<'a> {
  type Encode (line 62) | pub(crate) struct Encode<'a, T> {
  type Wants (line 70) | struct Wants(u8);
    constant EMPTY (line 73) | const EMPTY: Wants = Wants(0b00);
    constant EXPECT (line 74) | const EXPECT: Wants = Wants(0b01);
    constant UPGRADE (line 75) | const UPGRADE: Wants = Wants(0b10);
    method add (line 79) | fn add(self, other: Wants) -> Wants {
    method contains (line 84) | fn contains(&self, other: Wants) -> bool {
  type Http1OptionsBuilder (line 92) | pub struct Http1OptionsBuilder {
    method http09_responses (line 132) | pub fn http09_responses(mut self, enabled: bool) -> Self {
    method writev (line 150) | pub fn writev(mut self, writev: Option<bool>) -> Self {
    method max_headers (line 169) | pub fn max_headers(mut self, max_headers: usize) -> Self {
    method read_buf_exact_size (line 180) | pub fn read_buf_exact_size(mut self, sz: Option<usize>) -> Self {
    method max_buf_size (line 197) | pub fn max_buf_size(mut self, max: usize) -> Self {
    method allow_spaces_after_header_name_in_responses (line 226) | pub fn allow_spaces_after_header_name_in_responses(mut self, enabled: ...
    method ignore_invalid_headers_in_responses (line 239) | pub fn ignore_invalid_headers_in_responses(mut self, enabled: bool) ->...
    method allow_obsolete_multiline_headers_in_responses (line 246) | pub fn allow_obsolete_multiline_headers_in_responses(mut self, value: ...
    method build (line 253) | pub fn build(self) -> Http1Options {
  type Http1Options (line 103) | pub struct Http1Options {
    method builder (line 260) | pub fn builder() -> Http1OptionsBuilder {

FILE: src/client/core/proto/http1/buf.rs
  type BufList (line 6) | pub(crate) struct BufList<T> {
  function new (line 13) | pub(crate) fn new() -> BufList<T> {
  function push (line 21) | pub(crate) fn push(&mut self, buf: T) {
  function bufs_cnt (line 28) | pub(crate) fn bufs_cnt(&self) -> usize {
  method remaining (line 35) | fn remaining(&self) -> usize {
  method chunk (line 40) | fn chunk(&self) -> &[u8] {
  method advance (line 45) | fn advance(&mut self, mut cnt: usize) {
  method chunks_vectored (line 65) | fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
  method copy_to_bytes (line 80) | fn copy_to_bytes(&mut self, len: usize) -> Bytes {
  function hello_world_buf (line 110) | fn hello_world_buf() -> BufList<Bytes> {
  function to_bytes_shorter (line 119) | fn to_bytes_shorter() {
  function to_bytes_eq (line 131) | fn to_bytes_eq() {
  function to_bytes_longer (line 142) | fn to_bytes_longer() {
  function one_long_buf_to_bytes (line 150) | fn one_long_buf_to_bytes() {
  function buf_to_bytes_too_many (line 159) | fn buf_to_bytes_too_many() {

FILE: src/client/core/proto/http1/conn.rs
  type Conn (line 36) | pub(crate) struct Conn<I, B, T> {
  function new (line 48) | pub(crate) fn new(io: I) -> Conn<I, B, T> {
  function set_write_strategy_queue (line 74) | pub(crate) fn set_write_strategy_queue(&mut self) {
  function set_max_buf_size (line 79) | pub(crate) fn set_max_buf_size(&mut self, max: usize) {
  function set_read_buf_exact_size (line 84) | pub(crate) fn set_read_buf_exact_size(&mut self, sz: usize) {
  function set_write_strategy_flatten (line 89) | pub(crate) fn set_write_strategy_flatten(&mut self) {
  function set_h1_parser_config (line 94) | pub(crate) fn set_h1_parser_config(&mut self, parser_config: ParserConfi...
  function set_h09_responses (line 99) | pub(crate) fn set_h09_responses(&mut self) {
  function set_http1_max_headers (line 104) | pub(crate) fn set_http1_max_headers(&mut self, val: usize) {
  function into_inner (line 109) | pub(super) fn into_inner(self) -> (I, Bytes) {
  function pending_upgrade (line 114) | pub(super) fn pending_upgrade(&mut self) -> Option<upgrade::Pending> {
  function is_read_closed (line 119) | pub(super) fn is_read_closed(&self) -> bool {
  function is_write_closed (line 124) | pub(super) fn is_write_closed(&self) -> bool {
  function can_read_head (line 128) | pub(super) fn can_read_head(&self) -> bool {
  function can_read_body (line 137) | pub(super) fn can_read_body(&self) -> bool {
  function should_error_on_eof (line 145) | fn should_error_on_eof(&self) -> bool {
  function has_h2_prefix (line 151) | fn has_h2_prefix(&self) -> bool {
  function poll_read_head (line 158) | pub(super) fn poll_read_head(
  function on_read_head_error (line 234) | fn on_read_head_error<Z>(&mut self, e: Error) -> Poll<Option<Result<Z>>> {
  function poll_read_body (line 260) | pub(super) fn poll_read_body(
  function wants_read_again (line 327) | pub(super) fn wants_read_again(&mut self) -> bool {
  function poll_read_keep_alive (line 333) | pub(super) fn poll_read_keep_alive(&mut self, cx: &mut Context<'_>) -> P...
  function is_mid_message (line 346) | fn is_mid_message(&self) -> bool {
  function require_empty_read (line 357) | fn require_empty_read(&mut self, cx: &mut Context<'_>) -> Poll<Result<()...
  function mid_message_detect_eof (line 389) | fn mid_message_detect_eof(&mut self, cx: &mut Context<'_>) -> Poll<Resul...
  function force_io_read (line 408) | fn force_io_read(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<usi...
  function maybe_notify (line 420) | fn maybe_notify(&mut self, cx: &mut Context<'_>) {
  function try_keep_alive (line 468) | fn try_keep_alive(&mut self, cx: &mut Context<'_>) {
  function can_write_head (line 474) | pub(super) fn can_write_head(&self) -> bool {
  function can_write_body (line 486) | pub(super) fn can_write_body(&self) -> bool {
  function can_buffer_body (line 494) | pub(super) fn can_buffer_body(&self) -> bool {
  function write_head (line 498) | pub(super) fn write_head(&mut self, head: MessageHead<T::Outgoing>, body...
  function encode_head (line 510) | fn encode_head(
  function fix_keep_alive (line 548) | fn fix_keep_alive(&mut self, head: &mut MessageHead<T::Outgoing>) {
  function enforce_version (line 572) | fn enforce_version(&mut self, head: &mut MessageHead<T::Outgoing>) {
  function write_body (line 594) | pub(super) fn write_body(&mut self, chunk: B) {
  function write_trailers (line 619) | pub(super) fn write_trailers(&mut self, trailers: HeaderMap) {
  function write_body_and_end (line 638) | pub(super) fn write_body_and_end(&mut self, chunk: B) {
  function end_body (line 658) | pub(super) fn end_body(&mut self) -> Result<()> {
  function on_parse_error (line 693) | fn on_parse_error(&mut self, err: Error) -> Result<()> {
  function poll_flush (line 712) | pub(super) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Re...
  function poll_shutdown (line 719) | pub(super) fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io:...
  function poll_drain_or_close_read (line 733) | pub(super) fn poll_drain_or_close_read(&mut self, cx: &mut Context<'_>) {
  function close_read (line 752) | pub(super) fn close_read(&mut self) {
  function close_write (line 757) | pub(super) fn close_write(&mut self) {
  function take_error (line 761) | pub(super) fn take_error(&mut self) -> Result<()> {
  function on_upgrade (line 770) | pub(super) fn on_upgrade(&mut self) -> upgrade::OnUpgrade {
  function fmt (line 777) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type State (line 788) | struct State {
    method fmt (line 837) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method close (line 909) | fn close(&mut self) {
    method close_read (line 916) | fn close_read(&mut self) {
    method close_write (line 922) | fn close_write(&mut self) {
    method wants_keep_alive (line 929) | fn wants_keep_alive(&self) -> bool {
    method try_keep_alive (line 933) | fn try_keep_alive<T: Http1Transaction>(&mut self) {
    method disable_keep_alive (line 955) | fn disable_keep_alive(&mut self) {
    method busy (line 959) | fn busy(&mut self) {
    method idle (line 966) | fn idle<T: Http1Transaction>(&mut self) {
    method is_idle (line 987) | fn is_idle(&self) -> bool {
    method is_read_closed (line 992) | fn is_read_closed(&self) -> bool {
    method is_write_closed (line 997) | fn is_write_closed(&self) -> bool {
    method prepare_upgrade (line 1002) | fn prepare_upgrade(&mut self) -> upgrade::OnUpgrade {
  type Reading (line 821) | enum Reading {
  type Writing (line 829) | enum Writing {
    method fmt (line 859) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type KA (line 879) | enum KA {
    method bitand_assign (line 870) | fn bitand_assign(&mut self, enabled: bool) {
    method idle (line 888) | fn idle(&mut self) {
    method busy (line 893) | fn busy(&mut self) {
    method disable (line 898) | fn disable(&mut self) {
    method status (line 903) | fn status(&self) -> KA {

FILE: src/client/core/proto/http1/decode.rs
  constant CHUNKED_EXTENSIONS_LIMIT (line 17) | const CHUNKED_EXTENSIONS_LIMIT: u64 = 1024 * 16;
  constant TRAILER_LIMIT (line 22) | const TRAILER_LIMIT: usize = 1024 * 16;
  type Decoder (line 29) | pub(crate) struct Decoder {
    method length (line 97) | fn length(x: u64) -> Decoder {
    method eof (line 104) | fn eof() -> Decoder {
    method chunked (line 111) | fn chunked(h1_max_headers: Option<usize>, h1_max_header_size: Option<u...
    method new (line 125) | pub(super) fn new(
    method is_eof (line 138) | pub(crate) fn is_eof(&self) -> bool {
    method decode (line 150) | pub(crate) fn decode<R: MemRead>(
    method decode_fut (line 254) | async fn decode_fut<R: MemRead>(&mut self, body: &mut R) -> Result<Fra...
    method fmt (line 260) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Kind (line 34) | enum Kind {
  type ChunkedState (line 67) | enum ChunkedState {
    method new (line 305) | fn new() -> ChunkedState {
    method step (line 310) | fn step<R: MemRead>(
    method read_start (line 343) | fn read_start<R: MemRead>(
    method read_size (line 375) | fn read_size<R: MemRead>(
    method read_size_lws (line 408) | fn read_size_lws<R: MemRead>(
    method read_extension (line 424) | fn read_extension<R: MemRead>(
    method read_size_lf (line 455) | fn read_size_lf<R: MemRead>(
    method read_body (line 477) | fn read_body<R: MemRead>(
    method read_body_cr (line 511) | fn read_body_cr<R: MemRead>(
    method read_body_lf (line 523) | fn read_body_lf<R: MemRead>(
    method read_trailer (line 536) | fn read_trailer<R: MemRead>(
    method read_trailer_lf (line 557) | fn read_trailer_lf<R: MemRead>(
    method read_end_cr (line 591) | fn read_end_cr<R: MemRead>(
    method read_end_lf (line 622) | fn read_end_lf<R: MemRead>(
  type StepArgs (line 83) | struct StepArgs<'a> {
  function decode_trailers (line 645) | fn decode_trailers(buf: &mut BytesMut, count: usize) -> Result<HeaderMap...
  type IncompleteBody (line 687) | struct IncompleteBody;
    method fmt (line 692) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method read_mem (line 708) | fn read_mem(&mut self, _: &mut Context<'_>, len: usize) -> Poll<io::Resu...
  method read_mem (line 722) | fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::Res...
  method read_mem (line 731) | fn read_mem(&mut self, _: &mut Context<'_>, len: usize) -> Poll<io::Resu...
  function test_read_chunk_size (line 739) | async fn test_read_chunk_size() {
  function test_read_sized_early_eof (line 854) | async fn test_read_sized_early_eof() {
  function test_read_chunked_early_eof (line 872) | async fn test_read_chunked_early_eof() {
  function test_read_chunked_single_read (line 893) | async fn test_read_chunked_single_read() {
  function test_read_chunked_with_missing_zero_digit (line 907) | async fn test_read_chunked_with_missing_zero_digit() {
  function test_read_chunked_extensions_over_limit (line 927) | async fn test_read_chunked_extensions_over_limit() {
  function test_read_chunked_trailer_with_missing_lf (line 958) | async fn test_read_chunked_trailer_with_missing_lf() {
  function test_read_chunked_after_eof (line 967) | async fn test_read_chunked_after_eof() {
  function read_async (line 1003) | async fn read_async(mut decoder: Decoder, content: &[u8], block_at: usiz...
  function all_async_cases (line 1039) | async fn all_async_cases(content: &str, expected: &str, decoder: Decoder) {
  function test_read_length_async (line 1048) | async fn test_read_length_async() {
  function test_read_chunked_async (line 1054) | async fn test_read_chunked_async() {
  function test_read_eof_async (line 1061) | async fn test_read_eof_async() {
  function test_decode_trailers (line 1067) | fn test_decode_trailers() {
  function test_trailer_max_headers_enforced (line 1082) | async fn test_trailer_max_headers_enforced() {
  function test_trailer_max_header_size_huge_trailer (line 1112) | async fn test_trailer_max_header_size_huge_trailer() {
  function test_trailer_max_header_size_many_small_trailers (line 1140) | async fn test_trailer_max_header_size_many_small_trailers() {

FILE: src/client/core/proto/http1/dispatch.rs
  type Dispatcher (line 24) | pub(crate) struct Dispatcher<D, Bs: Body, I, T> {
  type Dispatch (line 32) | pub(crate) trait Dispatch {
    method poll_msg (line 39) | fn poll_msg(
    method recv_msg (line 44) | fn recv_msg(&mut self, msg: Result<(Self::RecvItem, Incoming)>) -> Res...
    method poll_ready (line 46) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), ()>>;
    method should_poll (line 48) | fn should_poll(&self) -> bool;
    type PollItem (line 552) | type PollItem = RequestHead;
    type PollBody (line 553) | type PollBody = B;
    type PollError (line 554) | type PollError = Infallible;
    type RecvItem (line 555) | type RecvItem = proto::ResponseHead;
    method poll_msg (line 557) | fn poll_msg(
    method recv_msg (line 594) | fn recv_msg(&mut self, msg: Result<(Self::RecvItem, Incoming)>) -> Res...
    method poll_ready (line 636) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), ()>> {
    method should_poll (line 650) | fn should_poll(&self) -> bool {
  type ClientRx (line 60) | type ClientRx<B> = dispatch::Receiver<Request<B>, http::Response<Incomin...
  function new (line 76) | pub(crate) fn new(dispatch: D, conn: Conn<I, Bs::Data, T>) -> Self {
  function into_inner (line 87) | pub(crate) fn into_inner(self) -> (I, Bytes, D) {
  function poll_catch (line 92) | fn poll_catch(
  function poll_inner (line 111) | fn poll_inner(
  function poll_loop (line 134) | fn poll_loop(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>> {
  function poll_read (line 191) | fn poll_read(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>> {
  function poll_read_head (line 267) | fn poll_read_head(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>> {
  function poll_write (line 323) | fn poll_write(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>> {
  function poll_flush (line 419) | fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>> {
  function close (line 427) | fn close(&mut self) {
  function can_write_again (line 434) | fn can_write_again(&mut self) -> bool {
  function is_done (line 438) | fn is_done(&self) -> bool {
  type Output (line 469) | type Output = Result<Dispatched>;
  method poll (line 472) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type OptGuard (line 481) | struct OptGuard<'a, T>(Pin<&'a mut Option<T>>, bool);
  function new (line 485) | fn new(pin: Pin<&'a mut Option<T>>) -> Self {
  function guard_mut (line 490) | fn guard_mut(&mut self) -> (Option<Pin<&mut T>>, &mut bool) {
  method drop (line 497) | fn drop(&mut self) {
  type SenderGuard (line 512) | struct SenderGuard(Option<body::Sender>);
    method set (line 516) | fn set(&mut self, sender: body::Sender) {
    method take (line 521) | fn take(&mut self) -> Option<body::Sender> {
  method drop (line 528) | fn drop(&mut self) {
  function new (line 539) | pub(crate) fn new(rx: ClientRx<B>) -> Client<B> {
  function client_read_bytes_before_writing_request (line 662) | fn client_read_bytes_before_writing_request() {
  function client_flushing_is_not_ready_for_next_request (line 695) | async fn client_flushing_is_not_ready_for_next_request() {
  function body_empty_chunks_ignored (line 729) | async fn body_empty_chunks_ignored() {

FILE: src/client/core/proto/http1/encode.rs
  type StaticBuf (line 17) | type StaticBuf = &'static [u8];
  type Encoder (line 21) | pub(crate) struct Encoder {
    method new (line 55) | fn new(kind: Kind) -> Encoder {
    method chunked (line 63) | pub(crate) fn chunked() -> Encoder {
    method length (line 68) | pub(crate) fn length(len: u64) -> Encoder {
    method into_chunked_with_trailing_fields (line 73) | pub(crate) fn into_chunked_with_trailing_fields(self, trailers: Vec<He...
    method is_eof (line 84) | pub(crate) fn is_eof(&self) -> bool {
    method is_last (line 89) | pub(crate) fn is_last(&self) -> bool {
    method is_close_delimited (line 94) | pub(crate) fn is_close_delimited(&self) -> bool {
    method is_chunked (line 99) | pub(crate) fn is_chunked(&self) -> bool {
    method end (line 103) | pub(crate) fn end<B>(&self) -> Result<Option<EncodedBuf<B>>, NotEof> {
    method encode (line 113) | pub(crate) fn encode<B>(&mut self, msg: B) -> EncodedBuf<B>
    method encode_trailers (line 143) | pub(crate) fn encode_trailers<B>(&self, trailers: HeaderMap) -> Option...
    method encode_and_end (line 191) | pub(super) fn encode_and_end<B>(&self, msg: B, dst: &mut WriteBuf<Enco...
  type EncodedBuf (line 27) | pub(crate) struct EncodedBuf<B> {
  type NotEof (line 32) | pub(crate) struct NotEof(u64);
    method fmt (line 390) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Kind (line 35) | enum Kind {
  type BufKind (line 45) | enum BufKind<B> {
  function is_valid_trailer_field (line 230) | fn is_valid_trailer_field(name: &HeaderName) -> bool {
  method remaining (line 253) | fn remaining(&self) -> usize {
  method chunk (line 264) | fn chunk(&self) -> &[u8] {
  method advance (line 275) | fn advance(&mut self, cnt: usize) {
  method chunks_vectored (line 286) | fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
  constant USIZE_BYTES (line 298) | const USIZE_BYTES: usize = 4;
  constant USIZE_BYTES (line 301) | const USIZE_BYTES: usize = 8;
  constant CHUNK_SIZE_MAX_BYTES (line 304) | const CHUNK_SIZE_MAX_BYTES: usize = USIZE_BYTES * 2;
  type ChunkSize (line 307) | struct ChunkSize {
    method new (line 314) | fn new(len: usize) -> ChunkSize {
    method fmt (line 346) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method write_str (line 355) | fn write_str(&mut self, num: &str) -> fmt::Result {
  method remaining (line 328) | fn remaining(&self) -> usize {
  method chunk (line 333) | fn chunk(&self) -> &[u8] {
  method advance (line 338) | fn advance(&mut self, cnt: usize) {
  function from (line 366) | fn from(buf: B) -> Self {
  function from (line 374) | fn from(buf: Take<B>) -> Self {
  function from (line 382) | fn from(buf: Chain<Chain<ChunkSize, B>, StaticBuf>) -> Self {
  function chunked (line 411) | fn chunked() {
  function length (line 436) | fn length() {
  function chunked_with_valid_trailers (line 460) | fn chunked_with_valid_trailers() {
  function chunked_with_multiple_trailer_headers (line 484) | fn chunked_with_multiple_trailer_headers() {
  function chunked_with_no_trailer_header (line 514) | fn chunked_with_no_trailer_header() {
  function chunked_with_invalid_trailers (line 531) | fn chunked_with_invalid_trailers() {
  function chunked_trailers_case_insensitive_matching (line 562) | fn chunked_trailers_case_insensitive_matching() {

FILE: src/client/core/proto/http1/ext.rs
  type ReasonPhrase (line 15) | pub struct ReasonPhrase(Bytes);
    method from_bytes_unchecked (line 24) | pub(crate) fn from_bytes_unchecked(reason: Bytes) -> Self {
    method as_ref (line 32) | fn as_ref(&self) -> &[u8] {

FILE: src/client/core/proto/http1/io.rs
  constant INIT_BUFFER_SIZE (line 16) | pub(crate) const INIT_BUFFER_SIZE: usize = 8192;
  constant MINIMUM_MAX_BUFFER_SIZE (line 19) | pub(crate) const MINIMUM_MAX_BUFFER_SIZE: usize = INIT_BUFFER_SIZE;
  constant DEFAULT_MAX_BUFFER_SIZE (line 24) | pub(crate) const DEFAULT_MAX_BUFFER_SIZE: usize = 8192 + 4096 * 100;
  constant MAX_BUF_LIST_BUFFERS (line 31) | const MAX_BUF_LIST_BUFFERS: usize = 16;
  type Buffered (line 33) | pub(crate) struct Buffered<T, B> {
  function fmt (line 47) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 60) | pub(crate) fn new(io: T) -> Buffered<T, B> {
  function set_max_buf_size (line 79) | pub(crate) fn set_max_buf_size(&mut self, max: usize) {
  function set_read_buf_exact_size (line 89) | pub(crate) fn set_read_buf_exact_size(&mut self, sz: usize) {
  function set_write_strategy_flatten (line 94) | pub(crate) fn set_write_strategy_flatten(&mut self) {
  function set_write_strategy_queue (line 102) | pub(crate) fn set_write_strategy_queue(&mut self) {
  function read_buf (line 110) | pub(crate) fn read_buf(&self) -> &[u8] {
  function read_buf_remaining_mut (line 117) | fn read_buf_remaining_mut(&self) -> usize {
  function can_headers_buf (line 126) | pub(crate) fn can_headers_buf(&self) -> bool {
  function headers_buf (line 131) | pub(crate) fn headers_buf(&mut self) -> &mut Vec<u8> {
  function write_buf (line 137) | pub(super) fn write_buf(&mut self) -> &mut WriteBuf<B> {
  function buffer (line 142) | pub(crate) fn buffer<BB: Buf + Into<B>>(&mut self, buf: BB) {
  function can_buffer (line 147) | pub(crate) fn can_buffer(&self) -> bool {
  function consume_leading_lines (line 151) | pub(crate) fn consume_leading_lines(&mut self) {
  function parse (line 164) | pub(super) fn parse<S>(
  function poll_read_from_io (line 212) | pub(crate) fn poll_read_from_io(&mut self, cx: &mut Context<'_>) -> Poll...
  function into_inner (line 234) | pub(crate) fn into_inner(self) -> (T, Bytes) {
  function io_mut (line 239) | pub(crate) fn io_mut(&mut self) -> &mut T {
  function is_read_blocked (line 244) | pub(crate) fn is_read_blocked(&self) -> bool {
  function poll_flush (line 248) | pub(crate) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Re...
  function poll_flush_flattened (line 287) | fn poll_flush_flattened(&mut self, cx: &mut Context<'_>) -> Poll<io::Res...
  type MemRead (line 311) | pub(crate) trait MemRead {
    method read_mem (line 312) | fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::R...
    method read_mem (line 320) | fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<io::R...
  type ReadStrategy (line 332) | enum ReadStrategy {
    method with_max (line 342) | fn with_max(max: usize) -> ReadStrategy {
    method next (line 350) | fn next(&self) -> usize {
    method max (line 357) | fn max(&self) -> usize {
    method record (line 364) | fn record(&mut self, bytes_read: usize) {
  function incr_power_of_two (line 398) | fn incr_power_of_two(n: usize) -> usize {
  function prev_power_of_two (line 402) | fn prev_power_of_two(n: usize) -> usize {
  method default (line 410) | fn default() -> ReadStrategy {
  type Cursor (line 416) | pub(crate) struct Cursor<T> {
  function new (line 423) | pub(crate) fn new(bytes: T) -> Cursor<T> {
  function maybe_unshift (line 432) | fn maybe_unshift(&mut self, additional: usize) {
  function reset (line 447) | fn reset(&mut self) {
  function fmt (line 454) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method remaining (line 464) | fn remaining(&self) -> usize {
  method chunk (line 469) | fn chunk(&self) -> &[u8] {
  method advance (line 474) | fn advance(&mut self, cnt: usize) {
  type WriteBuf (line 481) | pub(super) struct WriteBuf<B> {
  function new (line 491) | fn new(strategy: WriteStrategy) -> WriteBuf<B> {
  function set_strategy (line 506) | fn set_strategy(&mut self, strategy: WriteStrategy) {
  function buffer (line 510) | pub(super) fn buffer<BB: Buf + Into<B>>(&mut self, mut buf: BB) {
  function can_buffer (line 548) | fn can_buffer(&self) -> bool {
  function headers_mut (line 558) | fn headers_mut(&mut self) -> &mut Cursor<Vec<u8>> {
  function fmt (line 565) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method remaining (line 575) | fn remaining(&self) -> usize {
  method chunk (line 580) | fn chunk(&self) -> &[u8] {
  method advance (line 590) | fn advance(&mut self, cnt: usize) {
  method chunks_vectored (line 605) | fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
  type WriteStrategy (line 612) | enum WriteStrategy {
  function flush (line 630) | fn flush(&mut self) -> impl std::future::Future<Output = io::Result<()>>...
  function parse_reads_until_blocked (line 636) | async fn parse_reads_until_blocked() {
  function read_strategy_adaptive_increments (line 676) | fn read_strategy_adaptive_increments() {
  function read_strategy_adaptive_decrements (line 702) | fn read_strategy_adaptive_decrements() {
  function read_strategy_adaptive_stays_the_same (line 733) | fn read_strategy_adaptive_stays_the_same() {
  function read_strategy_adaptive_max_fuzz (line 754) | fn read_strategy_adaptive_max_fuzz() {
  function write_buf_requires_non_empty_bufs (line 783) | fn write_buf_requires_non_empty_bufs() {
  function write_buf_flatten (line 791) | async fn write_buf_flatten() {
  function write_buf_flatten_partially_flushed (line 811) | fn write_buf_flatten_partially_flushed() {
  function write_buf_queue_disable_auto (line 846) | async fn write_buf_queue_disable_auto() {

FILE: src/client/core/proto/http1/role.rs
  constant AVERAGE_HEADER_SIZE (line 26) | const AVERAGE_HEADER_SIZE: usize = 30;
  constant DEFAULT_MAX_HEADERS (line 27) | pub(crate) const DEFAULT_MAX_HEADERS: usize = 100;
  function parse_headers (line 63) | pub(super) fn parse_headers<T>(
  function is_complete_fast (line 90) | fn is_complete_fast(bytes: &[u8], prev_len: usize) -> bool {
  type Client (line 107) | pub(crate) enum Client {}
    method decoder (line 309) | fn decoder(
    method set_length (line 377) | fn set_length(head: &mut RequestHead, body: Option<BodyLength>) -> Enc...
    method obs_fold_line (line 509) | fn obs_fold_line(all: &mut [u8], idx: &mut HeaderIndices) {
  type Incoming (line 110) | type Incoming = StatusCode;
  type Outgoing (line 112) | type Outgoing = RequestLine;
  constant LOG (line 115) | const LOG: &'static str = "{role=client}";
  method parse (line 117) | fn parse(
  method encode (line 258) | fn encode(msg: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> Result<...
  method on_error (line 299) | fn on_error(_err: &Error) -> Option<MessageHead<Self::Outgoing>> {
  function set_content_length (line 569) | fn set_content_length(headers: &mut HeaderMap, len: u64) -> Encoder {
  type HeaderIndices (line 603) | struct HeaderIndices {
  function record_header_indices (line 608) | fn record_header_indices(
  function write_headers (line 634) | pub(crate) fn write_headers(headers: &HeaderMap, dst: &mut Vec<u8>) {
  function write_headers_original_case (line 643) | fn write_headers_original_case(
  type FastWrite (line 662) | struct FastWrite<'a>(&'a mut Vec<u8>);
  function write_str (line 666) | fn write_str(&mut self, s: &str) -> fmt::Result {
  function write_fmt (line 672) | fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
  function extend (line 678) | fn extend(dst: &mut Vec<u8>, data: &[u8]) {

FILE: src/client/core/proto/http2.rs
  constant SPEC_WINDOW_SIZE (line 30) | const SPEC_WINDOW_SIZE: u32 = 65_535;
  constant DEFAULT_CONN_WINDOW (line 35) | const DEFAULT_CONN_WINDOW: u32 = 1024 * 1024 * 5;
  constant DEFAULT_STREAM_WINDOW (line 36) | const DEFAULT_STREAM_WINDOW: u32 = 1024 * 1024 * 2;
  constant DEFAULT_MAX_FRAME_SIZE (line 37) | const DEFAULT_MAX_FRAME_SIZE: u32 = 1024 * 16;
  constant DEFAULT_MAX_SEND_BUF_SIZE (line 38) | const DEFAULT_MAX_SEND_BUF_SIZE: usize = 1024 * 1024;
  constant DEFAULT_MAX_HEADER_LIST_SIZE (line 39) | const DEFAULT_MAX_HEADER_LIST_SIZE: u32 = 1024 * 16;
  constant DEFAULT_INITIAL_MAX_SEND_STREAMS (line 48) | const DEFAULT_INITIAL_MAX_SEND_STREAMS: usize = 100;
  function strip_connection_headers (line 61) | fn strip_connection_headers(headers: &mut HeaderMap, is_request: bool) {
  function new (line 119) | fn new(stream: S, body_tx: SendStream<SendBuf<S::Data>>) -> PipeToSendSt...
  function send_reset (line 128) | fn send_reset(self: Pin<&mut Self>, reason: http2::Reason) {
  type Output (line 138) | type Output = Result<()>;
  method poll (line 140) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type SendStreamExt (line 216) | trait SendStreamExt {
    method on_user_err (line 217) | fn on_user_err<E>(&mut self, err: E) -> Error
    method send_eos_frame (line 221) | fn send_eos_frame(&mut self) -> Result<()>;
    method on_user_err (line 225) | fn on_user_err<E>(&mut self, err: E) -> Error
    method send_eos_frame (line 235) | fn send_eos_frame(&mut self) -> Result<()> {
  type SendBuf (line 243) | enum SendBuf<B> {
  method remaining (line 251) | fn remaining(&self) -> usize {
  method chunk (line 260) | fn chunk(&self) -> &[u8] {
  method advance (line 269) | fn advance(&mut self, cnt: usize) {
  method chunks_vectored (line 277) | fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
  type H2Upgraded (line 286) | struct H2Upgraded<B>
  method poll_read (line 300) | fn poll_read(
  method poll_write (line 340) | fn poll_write(
  method poll_flush (line 378) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::R...
  method poll_shutdown (line 382) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  function h2_to_io_error (line 404) | fn h2_to_io_error(e: http2::Error) -> std::io::Error {
  type Http2OptionsBuilder (line 416) | pub struct Http2OptionsBuilder {
    method initial_window_size (line 505) | pub fn initial_window_size(mut self, sz: impl Into<Option<u32>>) -> Se...
    method initial_connection_window_size (line 519) | pub fn initial_connection_window_size(mut self, sz: impl Into<Option<u...
    method initial_max_send_streams (line 538) | pub fn initial_max_send_streams(mut self, initial: impl Into<Option<us...
    method initial_stream_id (line 547) | pub fn initial_stream_id(mut self, id: impl Into<Option<u32>>) -> Self {
    method adaptive_window (line 560) | pub fn adaptive_window(mut self, enabled: bool) -> Self {
    method max_frame_size (line 573) | pub fn max_frame_size(mut self, sz: impl Into<Option<u32>>) -> Self {
    method max_header_list_size (line 584) | pub fn max_header_list_size(mut self, max: u32) -> Self {
    method header_table_size (line 597) | pub fn header_table_size(mut self, size: impl Into<Option<u32>>) -> Se...
    method max_concurrent_streams (line 628) | pub fn max_concurrent_streams(mut self, max: impl Into<Option<u32>>) -...
    method keep_alive_interval (line 642) | pub fn keep_alive_interval(mut self, interval: impl Into<Option<Durati...
    method keep_alive_timeout (line 654) | pub fn keep_alive_timeout(mut self, timeout: Duration) -> Self {
    method keep_alive_while_idle (line 668) | pub fn keep_alive_while_idle(mut self, enabled: bool) -> Self {
    method enable_push (line 677) | pub fn enable_push(mut self, opt: bool) -> Self {
    method enable_connect_protocol (line 684) | pub fn enable_connect_protocol(mut self, opt: bool) -> Self {
    method no_rfc7540_priorities (line 692) | pub fn no_rfc7540_priorities(mut self, opt: bool) -> Self {
    method max_concurrent_reset_streams (line 706) | pub fn max_concurrent_reset_streams(mut self, max: usize) -> Self {
    method max_send_buf_size (line 719) | pub fn max_send_buf_size(mut self, max: usize) -> Self {
    method max_pending_accept_reset_streams (line 729) | pub fn max_pending_accept_reset_streams(mut self, max: impl Into<Optio...
    method headers_stream_dependency (line 742) | pub fn headers_stream_dependency<T>(mut self, stream_dependency: T) ->...
    method headers_pseudo_order (line 758) | pub fn headers_pseudo_order<T>(mut self, headers_pseudo_order: T) -> Self
    method settings_order (line 773) | pub fn settings_order<T>(mut self, settings_order: T) -> Self
    method priorities (line 793) | pub fn priorities<T>(mut self, priorities: T) -> Self
    method build (line 805) | pub fn build(self) -> Http2Options {
  type Http2Options (line 427) | pub struct Http2Options {
    method builder (line 812) | pub fn builder() -> Http2OptionsBuilder {
  method default (line 828) | fn default() -> Self {
  function setup_duplex_test_server (line 866) | fn setup_duplex_test_server() -> (tokio::io::DuplexStream, tokio::io::Du...
  function h2_pipe_task_cancelled_on_response_future_drop (line 873) | async fn h2_pipe_task_cancelled_on_response_future_drop() {

FILE: src/client/core/proto/http2/client.rs
  type ClientRx (line 46) | type ClientRx<B> = dispatch::Receiver<Request<B>, Response<Incoming>>;
  type ConnDropRef (line 50) | type ConnDropRef = mpsc::Sender<Infallible>;
  type ConnEof (line 54) | type ConnEof = oneshot::Receiver<Infallible>;
  function handshake (line 56) | pub(crate) async fn handshake<T, B, E>(
  type Output (line 130) | type Output = Result<(), http2::Error>;
  method poll (line 132) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 170) | type Output = Result<(), ()>;
  method poll (line 172) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method is_terminated (line 194) | fn is_terminated(&self) -> bool {
  function new (line 222) | fn new(
  type Output (line 240) | type Output = ();
  method poll (line 242) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 295) | type Output = ();
  method poll (line 297) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> std::task::Poll<S...
  type FutCtx (line 308) | struct FutCtx<B>
  type ClientTask (line 322) | pub(crate) struct ClientTask<B, E, T>
  type Output (line 357) | type Output = ();
  method poll (line 359) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> std::task::Poll<S...
  function poll_pipe (line 406) | fn poll_pipe(&mut self, f: FutCtx<B>, cx: &mut Context<'_>) {
  function cancel (line 478) | pub(crate) fn cancel(self: Pin<&mut Self>) {
  type Output (line 490) | type Output = Result<Response<body::Incoming>, (Error, Option<Request<B>...
  method poll (line 492) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 558) | type Output = Result<Dispatched>;
  method poll (line 560) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: src/client/core/proto/http2/ping.rs
  type WindowSize (line 39) | type WindowSize = u32;
  function channel (line 41) | pub(super) fn channel(ping_pong: PingPong, config: Config, timer: Time) ...
  type Config (line 97) | pub(crate) struct Config {
    method new (line 186) | pub(crate) fn new(
    method is_enabled (line 206) | pub(super) fn is_enabled(&self) -> bool {
  type Recorder (line 109) | pub(crate) struct Recorder {
    method disabled (line 215) | pub(super) fn disabled() -> Recorder {
    method record_data (line 219) | pub(crate) fn record_data(&self, len: usize) {
    method record_non_data (line 249) | pub(crate) fn record_non_data(&self) {
    method for_stream (line 260) | pub(super) fn for_stream(self, stream: &http2::RecvStream) -> Self {
    method ensure_not_timed_out (line 268) | pub(super) fn ensure_not_timed_out(&self) -> Result<()> {
  type Ponger (line 113) | pub(super) struct Ponger {
    method is_idle (line 352) | fn is_idle(&self) -> bool {
  type Shared (line 119) | struct Shared {
    method send_ping (line 360) | fn send_ping(&mut self) {
    method is_ping_sent (line 373) | fn is_ping_sent(&self) -> bool {
    method update_last_read_at (line 378) | fn update_last_read_at(&mut self) {
    method last_read_at (line 385) | fn last_read_at(&self) -> Instant {
  type Bdp (line 140) | struct Bdp {
    method calculate (line 396) | fn calculate(&mut self, bytes: usize, rtt: Duration) -> Option<WindowS...
    method stabilize_delay (line 440) | fn stabilize_delay(&mut self) {
  type KeepAlive (line 155) | struct KeepAlive {
    method maybe_schedule (line 462) | fn maybe_schedule(&mut self, is_idle: bool, shared: &Shared) {
    method schedule (line 481) | fn schedule(&mut self, shared: &Shared) {
    method maybe_ping (line 487) | fn maybe_ping(&mut self, cx: &mut task::Context<'_>, is_idle: bool, sh...
    method maybe_timeout (line 513) | fn maybe_timeout(&mut self, cx: &mut task::Context<'_>) -> Result<(), ...
  type KeepAliveState (line 168) | enum KeepAliveState {
  type Ponged (line 174) | pub(super) enum Ponged {
  type KeepAliveTimedOut (line 180) | pub(super) struct KeepAliveTimedOut;
    method crate_error (line 530) | pub(super) fn crate_error(self) -> Error {
    method fmt (line 536) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method source (line 542) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
  type Output (line 283) | type Output = Ponged;
  method poll (line 286) | fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Se...
  constant BDP_LIMIT (line 393) | const BDP_LIMIT: usize = 1024 * 1024 * 16;
  function seconds (line 453) | fn seconds(dur: Duration) -> f64 {

FILE: src/client/core/rt.rs
  type Executor (line 22) | pub trait Executor<Fut> {
    method execute (line 24) | fn execute(&self, fut: Fut);

FILE: src/client/core/rt/bounds.rs
  type Http2ClientConnExec (line 23) | pub trait Http2ClientConnExec<B, T>: sealed_client::Sealed<(B, T)>
    method execute_h2_future (line 30) | fn execute_h2_future(&mut self, future: H2ClientFuture<B, T>);
  method execute_h2_future (line 42) | fn execute_h2_future(&mut self, future: H2ClientFuture<B, T>) {
  type Sealed (line 58) | pub trait Sealed<X> {}

FILE: src/client/core/rt/timer.rs
  type Timer (line 12) | pub trait Timer {
    method sleep (line 14) | fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>>;
    method sleep_until (line 17) | fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>>;
    method now (line 22) | fn now(&self) -> Instant {
    method reset (line 27) | fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
    method sleep (line 86) | fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
    method now (line 95) | fn now(&self) -> Instant {
    method sleep_until (line 102) | fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>> {
    method reset (line 111) | fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
  type Sleep (line 33) | pub trait Sleep: Send + Sync + Future<Output = ()> {
    method __type_id (line 36) | fn __type_id(&self, _: private::Sealed) -> TypeId
  type Time (line 46) | pub enum Time {
  function is (line 57) | pub fn is<T>(&self) -> bool
  function downcast_mut_pin (line 65) | pub fn downcast_mut_pin<T>(self: Pin<&mut Self>) -> Option<Pin<&mut T>>
  type Sealed (line 122) | pub struct Sealed {}

FILE: src/client/core/rt/tokio.rs
  type TokioExecutor (line 16) | pub struct TokioExecutor {}
    method execute (line 40) | fn execute(&self, fut: Fut) {
    method new (line 47) | pub fn new() -> Self {
  type TokioTimer (line 21) | pub struct TokioTimer;
    method new (line 80) | pub fn new() -> Self {
  method sleep (line 55) | fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
  method sleep_until (line 61) | fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>> {
  method now (line 67) | fn now(&self) -> Instant {
  method reset (line 71) | fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
  type Output (line 88) | type Output = ();
  method poll (line 91) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  method reset (line 100) | fn reset(self: Pin<&mut Self>, deadline: Instant) {

FILE: src/client/core/upgrade.rs
  type Upgraded (line 53) | pub struct Upgraded {
    method new (line 96) | pub(crate) fn new<T>(io: T, read_buf: Bytes) -> Self
    method fmt (line 153) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type OnUpgrade (line 61) | pub struct OnUpgrade {
    method none (line 162) | pub(super) fn none() -> Self {
    method is_none (line 167) | pub(super) fn is_none(&self) -> bool {
  function on (line 74) | pub fn on<T: sealed::CanUpgrade>(msg: T) -> OnUpgrade {
  type Pending (line 78) | pub(crate) struct Pending {
    method fulfill (line 191) | pub(super) fn fulfill(self, upgraded: Upgraded) {
    method manual (line 199) | pub(super) fn manual(self) {
  function pending (line 82) | pub(crate) fn pending() -> (Pending, OnUpgrade) {
  method poll_read (line 108) | fn poll_read(
  method poll_write (line 119) | fn poll_write(
  method poll_write_vectored (line 128) | fn poll_write_vectored(
  method poll_flush (line 137) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 142) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method is_write_vectored (line 147) | fn is_write_vectored(&self) -> bool {
  type Output (line 173) | type Output = Result<Upgraded, Error>;
  method poll (line 175) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type UpgradeExpected (line 212) | struct UpgradeExpected;
    method fmt (line 215) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Io (line 224) | trait Io: AsyncRead + AsyncWrite + Unpin + 'static {}
  type CanUpgrade (line 231) | pub trait CanUpgrade {
    method on_upgrade (line 232) | fn on_upgrade(self) -> OnUpgrade;
    method on_upgrade (line 236) | fn on_upgrade(mut self) -> OnUpgrade {
    method on_upgrade (line 244) | fn on_upgrade(self) -> OnUpgrade {
    method on_upgrade (line 252) | fn on_upgrade(mut self) -> OnUpgrade {
    method on_upgrade (line 260) | fn on_upgrade(self) -> OnUpgrade {
  type Rewind (line 280) | pub(crate) struct Rewind<T> {
  function new_buffered (line 287) | pub(crate) fn new_buffered(io: T, buf: Bytes) -> Self {
  function rewind (line 295) | pub(crate) fn rewind(&mut self, bs: Bytes) {
  method poll_read (line 305) | fn poll_read(
  method poll_write (line 334) | fn poll_write(
  method poll_write_vectored (line 343) | fn poll_write_vectored(
  method poll_flush (line 352) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 357) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method is_write_vectored (line 362) | fn is_write_vectored(&self) -> bool {
  function partial_rewind (line 375) | async fn partial_rewind() {
  function full_rewind (line 397) | async fn full_rewind() {

FILE: src/client/emulate.rs
  type IntoEmulation (line 16) | pub trait IntoEmulation {
    method into_emulation (line 18) | fn into_emulation(self) -> Emulation;
    method into_emulation (line 119) | fn into_emulation(self) -> Emulation {
  type EmulationBuilder (line 24) | pub struct EmulationBuilder {
    method http1_options (line 57) | pub fn http1_options(mut self, opts: Http1Options) -> Self {
    method http2_options (line 64) | pub fn http2_options(mut self, opts: Http2Options) -> Self {
    method tls_options (line 71) | pub fn tls_options(mut self, opts: TlsOptions) -> Self {
    method headers (line 78) | pub fn headers(mut self, src: HeaderMap) -> Self {
    method orig_headers (line 85) | pub fn orig_headers(mut self, src: OrigHeaderMap) -> Self {
    method build (line 92) | pub fn build(mut self, group: Group) -> Emulation {
  type Emulation (line 33) | pub struct Emulation {
    method builder (line 103) | pub fn builder() -> EmulationBuilder {

FILE: src/client/future.rs
  type Output (line 29) | type Output = Result<Response, Error>;
  method poll (line 31) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function test_future_size (line 67) | fn test_future_size() {
  function error_has_url (line 73) | async fn error_has_url() {

FILE: src/client/group.rs
  type Group (line 61) | pub struct Group(BTreeMap<GroupId, GroupPart>);
    method named (line 66) | pub fn named<N: Into<Cow<'static, str>>>(name: N) -> Self {
    method number (line 74) | pub fn number<V: Into<u64>>(value: V) -> Self {
    method uri (line 83) | pub(crate) fn uri(&mut self, uri: Uri) -> &mut Self {
    method version (line 89) | pub(crate) fn version(&mut self, version: Option<Version>) -> &mut Self {
    method proxy (line 95) | pub(crate) fn proxy(&mut self, proxy: Option<Matcher>) -> &mut Self {
    method socket_bind (line 101) | pub(crate) fn socket_bind(&mut self, opts: Option<SocketBindOptions>) ...
    method request (line 107) | pub(crate) fn request(&mut self, group: Group) -> &mut Self {
    method emulate (line 113) | pub(crate) fn emulate(&mut self, group: Group) -> &mut Self {
    method extend (line 118) | fn extend<T: Into<Option<GroupPart>>>(&mut self, id: GroupId, entry: T...
    method from (line 128) | fn from(value: u64) -> Self {
    method from (line 135) | fn from(value: &'static str) -> Self {
    method from (line 142) | fn from(value: String) -> Self {
    method from (line 149) | fn from(value: Cow<'static, str>) -> Self {
  function test_group_identity_invariance (line 161) | fn test_group_identity_invariance() {

FILE: src/client/layer/client.rs
  type BoxSendFuture (line 63) | type BoxSendFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
  type HttpClient (line 70) | pub(crate) struct HttpClient<C, B> {
  type Config (line 82) | struct Config {
  type Error (line 89) | pub struct Error {
    method fmt (line 994) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 1006) | fn new<E>(kind: ErrorKind, error: E) -> Self
    method is_connect (line 1035) | pub fn is_connect(&self) -> bool {
    method is_proxy_connect (line 1041) | pub fn is_proxy_connect(&self) -> bool {
    method with_connect_info (line 1046) | fn with_connect_info(self, connect_info: Connected) -> Self {
    method is_canceled (line 1054) | fn is_canceled(&self) -> bool {
    method tx (line 1059) | fn tx(src: core::Error) -> Self {
    method closed (line 1064) | fn closed(src: core::Error) -> Self {
  type ErrorKind (line 97) | enum ErrorKind {
  type ClientConnectError (line 108) | enum ClientConnectError {
  type TrySendError (line 114) | enum TrySendError<B> {
  function builder (line 145) | pub fn builder<E>(executor: E) -> Builder
  function request (line 163) | fn request(
  function send_request (line 216) | async fn send_request(
  function try_send_request (line 249) | async fn try_send_request(
  function connection_for (line 384) | async fn connection_for(
  function one_connection_for (line 407) | async fn one_connection_for(
  function connect_to (line 498) | fn connect_to(
  type Response (line 689) | type Response = Response<Incoming>;
  type Error (line 690) | type Error = BoxError;
    method fmt (line 994) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method new (line 1006) | fn new<E>(kind: ErrorKind, error: E) -> Self
    method is_connect (line 1035) | pub fn is_connect(&self) -> bool {
    method is_proxy_connect (line 1041) | pub fn is_proxy_connect(&self) -> bool {
    method with_connect_info (line 1046) | fn with_connect_info(self, connect_info: Connected) -> Self {
    method is_canceled (line 1054) | fn is_canceled(&self) -> bool {
    method tx (line 1059) | fn tx(src: core::Error) -> Self {
    method closed (line 1064) | fn closed(src: core::Error) -> Self {
  type Future (line 691) | type Future = BoxFuture<'static, Result<Response<Incoming>, Self::Error>>;
  function poll_ready (line 693) | fn poll_ready(&mut self, _: &mut task::Context<'_>) -> Poll<Result<(), S...
  function call (line 697) | fn call(&mut self, req: Request<B>) -> Self::Future {
  method clone (line 703) | fn clone(&self) -> HttpClient<C, B> {
  type PoolClient (line 718) | struct PoolClient<B> {
  type PoolTx (line 723) | enum PoolTx<B> {
  function poll_ready (line 732) | fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), ...
  function is_http1 (line 740) | fn is_http1(&self) -> bool {
  function is_http2 (line 745) | fn is_http2(&self) -> bool {
  function is_poisoned (line 753) | fn is_poisoned(&self) -> bool {
  function is_ready (line 758) | fn is_ready(&self) -> bool {
  function try_send_request (line 768) | fn try_send_request(
  function is_open (line 787) | fn is_open(&self) -> bool {
  function reserve (line 791) | fn reserve(self) -> pool::Reservation<Self> {
  function can_share (line 813) | fn can_share(&self) -> bool {
  type Builder (line 820) | pub struct Builder {
    method new (line 835) | pub fn new<E>(executor: E) -> Self
    method pool_idle_timeout (line 866) | pub fn pool_idle_timeout<D>(mut self, val: D) -> Self
    method pool_max_idle_per_host (line 878) | pub fn pool_max_idle_per_host(mut self, max_idle: usize) -> Self {
    method pool_max_size (line 887) | pub fn pool_max_size(mut self, max_size: impl Into<Option<NonZeroUsize...
    method http2_only (line 903) | pub fn http2_only(mut self, val: bool) -> Self {
    method http2_timer (line 915) | pub fn http2_timer<M>(mut self, timer: M) -> Self
    method http1_options (line 925) | pub fn http1_options<O>(mut self, opts: O) -> Self
    method http2_options (line 938) | pub fn http2_options<O>(mut self, opts: O) -> Self
    method pool_timer (line 950) | pub fn pool_timer<M>(mut self, timer: M) -> Self
    method cookie_store (line 961) | pub fn cookie_store(mut self, cookie_store: Option<Arc<dyn CookieStore...
    method build (line 967) | pub fn build<C, B>(self, connector: C) -> HttpClient<C, B>
  method source (line 1000) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  function origin_form (line 1069) | fn origin_form(uri: &mut Uri) {
  function absolute_form (line 1084) | fn absolute_form(uri: &mut Uri) {
  function authority_form (line 1092) | fn authority_form(uri: &mut Uri) {
  function normalize_uri (line 1112) | fn normalize_uri<B>(req: &mut Request<B>, is_http_connect: bool) -> Resu...
  function generate_host_header (line 1141) | fn generate_host_header(uri: &Uri) -> HeaderValue {
  function set_scheme (line 1156) | fn set_scheme(uri: &mut Uri, scheme: Scheme) {
  function is_schema_secure (line 1168) | fn is_schema_secure(uri: &Uri) -> bool {

FILE: src/client/layer/client/exec.rs
  type BoxSendFuture (line 5) | pub(crate) type BoxSendFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
  type Exec (line 9) | pub struct Exec(Arc<dyn Executor<BoxSendFuture> + Send + Sync>);
    method new (line 14) | pub(super) fn new<E>(inner: E) -> Self
    method execute (line 26) | fn execute(&self, fut: F) {

FILE: src/client/layer/client/lazy.rs
  type Started (line 9) | pub(crate) trait Started: Future {
    method started (line 10) | fn started(&self) -> bool;
    method started (line 46) | fn started(&self) -> bool {
  function lazy (line 13) | pub(crate) fn lazy<F, R>(func: F) -> Lazy<F, R>
  type Output (line 59) | type Output = R::Output;
  method poll (line 61) | fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::...

FILE: src/client/layer/client/pool.rs
  type Pool (line 25) | pub struct Pool<T, K: Key> {
  type Poolable (line 35) | pub trait Poolable: Unpin + Send + Sized + 'static {
    method is_open (line 36) | fn is_open(&self) -> bool;
    method reserve (line 40) | fn reserve(self) -> Reservation<Self>;
    method can_share (line 41) | fn can_share(&self) -> bool;
    method is_open (line 830) | fn is_open(&self) -> bool {
    method reserve (line 834) | fn reserve(self) -> Reservation<Self> {
    method can_share (line 838) | fn can_share(&self) -> bool {
    method is_open (line 1063) | fn is_open(&self) -> bool {
    method reserve (line 1067) | fn reserve(self) -> Reservation<Self> {
    method can_share (line 1071) | fn can_share(&self) -> bool {
  type Key (line 44) | pub trait Key: Eq + Hash + Clone + Debug + Unpin + Send + 'static {}
  type Ver (line 51) | pub enum Ver {
  type Reservation (line 62) | pub enum Reservation<T> {
  type PoolInner (line 74) | struct PoolInner<T, K: Eq + Hash> {
  type WeakOpt (line 103) | struct WeakOpt<T>(Option<Weak<T>>);
  type Config (line 106) | pub struct Config {
    method is_enabled (line 113) | pub fn is_enabled(&self) -> bool {
  function new (line 119) | pub fn new<E>(config: Config, executor: E, timer: Time) -> Pool<T, K>
  function is_enabled (line 143) | pub(crate) fn is_enabled(&self) -> bool {
  function checkout (line 151) | pub fn checkout(&self, key: K) -> Checkout<T, K> {
  function connecting (line 161) | pub fn connecting(&self, key: K, ver: Ver) -> Option<Connecting<T, K>> {
  function pooled (line 187) | pub fn pooled(&self, mut connecting: Connecting<T, K>, value: T) -> Pool...
  function reuse (line 228) | fn reuse(&self, key: &K, value: T) -> Pooled<T, K> {
  type IdlePopper (line 255) | struct IdlePopper<'a, T, K> {
  function pop (line 262) | fn pop(self, expiration: &Expiration, now: Instant) -> Option<Idle<T>> {
  function now (line 303) | fn now(&self) -> Instant {
  function put (line 307) | fn put(&mut self, key: &K, value: T, __pool_ref: &Arc<Mutex<PoolInner<T,...
  function connected (line 377) | fn connected(&mut self, key: &K) {
  function spawn_idle_interval (line 386) | fn spawn_idle_interval(&mut self, pool_ref: &Arc<Mutex<PoolInner<T, K>>>) {
  function clean_waiters (line 437) | fn clean_waiters(&mut self, key: &K) {
  function clear_expired (line 451) | fn clear_expired(&mut self) {
  method clone (line 487) | fn clone(&self) -> Pool<T, K> {
  type Pooled (line 496) | pub struct Pooled<T: Poolable, K: Key> {
  function is_reused (line 504) | pub fn is_reused(&self) -> bool {
  function is_pool_enabled (line 508) | pub fn is_pool_enabled(&self) -> bool {
  function as_ref (line 512) | fn as_ref(&self) -> &T {
  function as_mut (line 516) | fn as_mut(&mut self) -> &mut T {
  type Target (line 522) | type Target = T;
  method deref (line 523) | fn deref(&self) -> &T {
  method deref_mut (line 529) | fn deref_mut(&mut self) -> &mut T {
  method drop (line 535) | fn drop(&mut self) {
  method fmt (line 556) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Idle (line 561) | struct Idle<T> {
  type Checkout (line 566) | pub struct Checkout<T, K: Key> {
  type Error (line 574) | pub enum Error {
    method is_canceled (line 581) | pub(super) fn is_canceled(&self) -> bool {
    method fmt (line 587) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function poll_waiter (line 599) | fn poll_waiter(
  function checkout (line 625) | fn checkout(&mut self, cx: &mut task::Context<'_>) -> Option<Pooled<T, K...
  type Output (line 677) | type Output = Result<Pooled<T, K>, Error>;
  method poll (line 679) | fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Se...
  method drop (line 697) | fn drop(&mut self) {
  type Connecting (line 707) | pub struct Connecting<T: Poolable, K: Key> {
  function alpn_h2 (line 713) | pub fn alpn_h2(self, pool: &Pool<T, K>) -> Option<Self> {
  method drop (line 724) | fn drop(&mut self) {
  type Expiration (line 733) | struct Expiration(Option<Duration>);
    method new (line 736) | fn new(dur: Option<Duration>) -> Expiration {
    method expires (line 740) | fn expires(&self, instant: Instant, now: Instant) -> bool {
  type IdleTask (line 749) | struct IdleTask<T, K: Key> {
  function run (line 760) | async fn run(self) {
  function none (line 790) | fn none() -> Self {
  function downgrade (line 794) | fn downgrade(arc: &Arc<T>) -> Self {
  function upgrade (line 798) | fn upgrade(&self) -> Option<Arc<T>> {
  type KeyImpl (line 823) | struct KeyImpl(http::uri::Scheme, http::uri::Authority);
  type Uniq (line 827) | struct Uniq<T>(T);
  function c (line 843) | fn c<T: Poolable, K: Key>(key: K) -> Connecting<T, K> {
  function host_key (line 850) | fn host_key(s: &str) -> KeyImpl {
  function pool_no_timer (line 854) | fn pool_no_timer<T, K: Key>() -> Pool<T, K> {
  function pool_max_idle_no_timer (line 858) | fn pool_max_idle_no_timer<T, K: Key>(max_idle: usize) -> Pool<T, K> {
  function locked (line 871) | fn locked(&self) -> MutexGuard<'_, super::PoolInner<T, K>> {
  function test_pool_checkout_smoke (line 877) | async fn test_pool_checkout_smoke() {
  type PollOnce (line 891) | struct PollOnce<'a, F>(&'a mut F);
  type Output (line 897) | type Output = Option<()>;
  method poll (line 899) | fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Se...
  function test_pool_checkout_returns_none_if_expired (line 909) | async fn test_pool_checkout_returns_none_if_expired() {
  function test_pool_checkout_removes_expired (line 924) | async fn test_pool_checkout_removes_expired() {
  function test_pool_max_idle_per_host (line 947) | fn test_pool_max_idle_per_host() {
  function test_pool_timer_removes_expired_realtime (line 963) | async fn test_pool_timer_removes_expired_realtime() {
  function test_pool_timer_removes_expired_faketime (line 968) | async fn test_pool_timer_removes_expired_faketime() {
  function test_pool_timer_removes_expired_inner (line 972) | async fn test_pool_timer_removes_expired_inner() {
  function test_pool_checkout_task_unparked (line 1010) | async fn test_pool_checkout_task_unparked() {
  function test_pool_checkout_drop_cleans_up_waiters (line 1031) | async fn test_pool_checkout_drop_cleans_up_waiters() {
  type CanClose (line 1056) | struct CanClose {
  function pooled_drop_if_closed_doesnt_reinsert (line 1077) | fn pooled_drop_if_closed_doesnt_reinsert() {
  function test_pool_size_limit (line 1092) | async fn test_pool_size_limit() {

FILE: src/client/layer/config.rs
  type DefaultHeaders (line 26) | pub(crate) struct DefaultHeaders;
  type RequestOptions (line 32) | pub(crate) struct RequestOptions {
  type Config (line 43) | struct Config {
  type ConfigServiceLayer (line 51) | pub struct ConfigServiceLayer {
    method new (line 74) | pub fn new(https_only: bool, headers: HeaderMap, orig_headers: OrigHea...
    type Service (line 88) | type Service = ConfigService<S>;
    method layer (line 91) | fn layer(&self, inner: S) -> Self::Service {
  type ConfigService (line 57) | pub struct ConfigService<S> {
  type Response (line 106) | type Response = S::Response;
  type Error (line 107) | type Error = S::Error;
  type Future (line 108) | type Future = Either<S::Future, Ready<Result<Self::Response, Self::Error...
  function poll_ready (line 111) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 115) | fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {

FILE: src/client/layer/decoder.rs
  type AcceptEncoding (line 18) | pub(crate) struct AcceptEncoding {
  type DecompressionLayer (line 31) | pub struct DecompressionLayer {
    method new (line 63) | pub fn new(accept: AcceptEncoding) -> Self {
    type Service (line 69) | type Service = Decompression<S>;
    method layer (line 72) | fn layer(&self, service: S) -> Self::Service {
  type Decompression (line 37) | pub struct Decompression<S>(Option<decompression::Decompression<S>>);
  method default (line 42) | fn default() -> AcceptEncoding {
  constant BUG_MSG (line 83) | const BUG_MSG: &str = "[BUG] Decompression service not initialized; bug ...
  function accept_in_place (line 85) | fn accept_in_place(
  type Response (line 119) | type Response = Response<DecompressionBody<ResBody>>;
  type Error (line 120) | type Error = S::Error;
  type Future (line 121) | type Future = ResponseFuture<S::Future>;
  function poll_ready (line 124) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 128) | fn call(&mut self, req: Request<ReqBody>) -> Self::Future {

FILE: src/client/layer/redirect.rs
  type BodyRepr (line 19) | enum BodyRepr<B> {
  function take (line 29) | fn take(&mut self) -> Option<B> {
  function try_clone_from (line 40) | fn try_clone_from<P, E>(&mut self, body: &B, policy: &P)
  type FollowRedirectLayer (line 59) | pub struct FollowRedirectLayer<P> {
  function with_policy (line 66) | pub fn with_policy(policy: P) -> Self {
  type Service (line 76) | type Service = FollowRedirect<S, P>;
  function layer (line 79) | fn layer(&self, inner: S) -> Self::Service {
  type FollowRedirect (line 86) | pub struct FollowRedirect<S, P> {
  function with_policy (line 97) | pub fn with_policy(inner: S, policy: P) -> Self {
  type Response (line 109) | type Response = Response<ResBody>;
  type Error (line 110) | type Error = S::Error;
  type Future (line 111) | type Future = ResponseFuture<S, ReqBody, P>;
  function poll_ready (line 114) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 118) | fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {

FILE: src/client/layer/redirect/future.rs
  type Pending (line 26) | pub struct Pending<ReqBody, Response> {
  type Output (line 64) | type Output = Result<Response<ResBody>, S::Error>;
  method poll (line 66) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function resolve_uri (line 196) | fn resolve_uri(relative: &str, base: &Uri) -> Option<Uri> {
  function drop_payload_headers (line 207) | fn drop_payload_headers(headers: &mut HeaderMap) {
  type RedirectFuturePin (line 218) | type RedirectFuturePin<'a, S, ReqBody> =
  type RedirectAction (line 221) | struct RedirectAction<'a, S, ReqBody, ResBody, P>
  function handle_action (line 237) | fn handle_action<S, ReqBody, ResBody, P>(

FILE: src/client/layer/redirect/policy.rs
  type Policy (line 10) | pub trait Policy<B, E> {
    method redirect (line 15) | fn redirect(&mut self, attempt: Attempt<'_>) -> Result<Action, E>;
    method follow_redirects (line 21) | fn follow_redirects(&mut self, _request: &mut Request<B>) -> bool;
    method on_request (line 24) | fn on_request(&mut self, _request: &mut Request<B>);
    method on_response (line 27) | fn on_response<Body>(&mut self, _response: &mut Response<Body>);
    method clone_body (line 30) | fn clone_body(&self, _body: &B) -> Option<B>;
  type Attempt (line 34) | pub struct Attempt<'a> {
  type Action (line 43) | pub enum Action {
    method fmt (line 55) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: src/client/layer/retry.rs
  type RetryPolicy (line 26) | pub struct RetryPolicy {
    method new (line 37) | pub fn new(policy: retry::Policy) -> Self {
    type Future (line 55) | type Future = Ready<()>;
    method retry (line 57) | fn retry(&mut self, req: &mut Req, result: &mut Result<Res, BoxError>)...
    method clone_request (line 101) | fn clone_request(&mut self, req: &Req) -> Option<Req> {
  type Req (line 50) | type Req = Request<Body>;
  type Res (line 52) | type Res = Response<Incoming>;
  function is_retryable_error (line 128) | fn is_retryable_error(err: &(dyn StdError + 'static)) -> bool {

FILE: src/client/layer/retry/classify.rs
  type Classify (line 8) | pub trait Classify: Send + Sync + 'static {
    method classify (line 9) | fn classify(&self, req_rep: ReqRep<'_>) -> Action;
    method classify (line 24) | fn classify(&self, req_rep: ReqRep<'_>) -> Action {
  type ClassifyFn (line 18) | pub struct ClassifyFn<F>(pub(crate) F);
  type ReqRep (line 31) | pub struct ReqRep<'a>(&'a Req, Result<StatusCode, &'a BoxError>);
  function method (line 35) | pub fn method(&self) -> &Method {
  function uri (line 40) | pub fn uri(&self) -> &Uri {
  function status (line 45) | pub fn status(&self) -> Option<StatusCode> {
  function error (line 50) | pub fn error(&self) -> Option<&(dyn StdError + 'static)> {
  function retryable (line 55) | pub fn retryable(self) -> Action {
  function success (line 60) | pub fn success(self) -> Action {
  type Action (line 67) | pub enum Action {
  type Classifier (line 76) | pub(crate) enum Classifier {
    method classify (line 87) | pub(super) fn classify(&mut self, req: &Req, res: &Result<Res, BoxErro...

FILE: src/client/layer/retry/scope.rs
  type Scope (line 5) | pub trait Scope: Send + Sync + 'static {
    method applies_to (line 6) | fn applies_to(&self, req: &super::Req) -> bool;
    method applies_to (line 27) | fn applies_to(&self, req: &Req) -> bool {
  type ScopeFn (line 21) | pub struct ScopeFn<F>(pub(crate) F);
  type Scoped (line 34) | pub(crate) enum Scoped {
    method applies_to (line 43) | pub(super) fn applies_to(&self, req: &super::Req) -> bool {

FILE: src/client/layer/timeout.rs
  type TimeoutOptions (line 24) | pub struct TimeoutOptions {
    method read_timeout (line 32) | pub fn read_timeout(&mut self, read_timeout: Duration) -> &mut Self {
    method total_timeout (line 39) | pub fn total_timeout(&mut self, total_timeout: Duration) -> &mut Self {
  type TimeoutLayer (line 50) | pub struct TimeoutLayer {
    method new (line 56) | pub fn new(options: TimeoutOptions) -> Self {
    type Service (line 64) | type Service = Timeout<S>;
    method layer (line 67) | fn layer(&self, service: S) -> Self::Service {
  type Timeout (line 77) | pub struct Timeout<T> {
  type Response (line 86) | type Response = S::Response;
  type Error (line 87) | type Error = BoxError;
  type Future (line 88) | type Future = ResponseFuture<S::Future>;
  function poll_ready (line 91) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 96) | fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
  type ResponseBodyTimeoutLayer (line 109) | pub struct ResponseBodyTimeoutLayer {
    method new (line 116) | pub fn new<M>(timer: M, options: TimeoutOptions) -> Self
    type Service (line 128) | type Service = ResponseBodyTimeout<S>;
    method layer (line 131) | fn layer(&self, inner: S) -> Self::Service {
  type ResponseBodyTimeout (line 143) | pub struct ResponseBodyTimeout<S> {
  type Response (line 153) | type Response = Response<TimeoutBody<ResBody>>;
  type Error (line 154) | type Error = S::Error;
  type Future (line 155) | type Future = ResponseBodyTimeoutFuture<S::Future>;
  function poll_ready (line 158) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 163) | fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
  function fetch_timeout_options (line 174) | fn fetch_timeout_options(

FILE: src/client/layer/timeout/body.rs
  function new (line 71) | pub fn new(
  type Data (line 111) | type Data = B::Data;
  type Error (line 112) | type Error = BoxError;
  method poll_frame (line 115) | fn poll_frame(
  method size_hint (line 128) | fn size_hint(&self) -> http_body::SizeHint {
  method is_end_stream (line 138) | fn is_end_stream(&self) -> bool {
  function poll_and_map_body (line 149) | fn poll_and_map_body<B>(
  type Data (line 168) | type Data = B::Data;
  type Error (line 169) | type Error = BoxError;
  method poll_frame (line 171) | fn poll_frame(
  method size_hint (line 183) | fn size_hint(&self) -> http_body::SizeHint {
  method is_end_stream (line 188) | fn is_end_stream(&self) -> bool {
  type Data (line 199) | type Data = B::Data;
  type Error (line 200) | type Error = BoxError;
  method poll_frame (line 202) | fn poll_frame(
  method size_hint (line 233) | fn size_hint(&self) -> http_body::SizeHint {
  method is_end_stream (line 238) | fn is_end_stream(&self) -> bool {

FILE: src/client/layer/timeout/future.rs
  type Output (line 35) | type Output = Result<T, BoxError>;
  method poll (line 37) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Output (line 85) | type Output = Result<Response<TimeoutBody<ResBody>>, E>;
  method poll (line 87) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: src/client/multipart.rs
  type Form (line 18) | pub struct Form {
    method new (line 50) | pub fn new() -> Form {
    method with_boundary (line 59) | pub fn with_boundary<S>(boundary: S) -> Form
    method boundary (line 72) | pub fn boundary(&self) -> &str {
    method text (line 85) | pub fn text<T, U>(self, name: T, value: U) -> Form
    method file (line 113) | pub async fn file<T, U>(self, name: T, path: U) -> io::Result<Form>
    method part (line 122) | pub fn part<T>(mut self, name: T, part: Part) -> Form
    method percent_encode_path_segment (line 131) | pub fn percent_encode_path_segment(mut self) -> Form {
    method percent_encode_attr_chars (line 137) | pub fn percent_encode_attr_chars(mut self) -> Form {
    method percent_encode_noop (line 143) | pub fn percent_encode_noop(mut self) -> Form {
    method stream (line 149) | pub(crate) fn stream(self) -> Body {
    method into_stream (line 158) | pub fn into_stream(mut self) -> impl Stream<Item = Result<Bytes, crate...
    method part_stream (line 186) | pub(crate) fn part_stream<T>(
    method compute_length (line 214) | pub(crate) fn compute_length(&mut self) -> Option<u64> {
    method take_fields (line 247) | fn take_fields(&mut self) -> Vec<(Cow<'static, str>, Part)> {
  type Part (line 27) | pub struct Part {
    method text (line 256) | pub fn text<T>(value: T) -> Part
    method bytes (line 268) | pub fn bytes<T>(value: T) -> Part
    method stream (line 280) | pub fn stream<T: Into<Body>>(value: T) -> Part {
    method stream_with_length (line 287) | pub fn stream_with_length<T: Into<Body>>(value: T, length: u64) -> Part {
    method file (line 298) | pub async fn file<T: AsRef<Path>>(path: T) -> io::Result<Part> {
    method new (line 320) | fn new(value: Body, body_length: Option<u64>) -> Part {
    method mime_str (line 329) | pub fn mime_str(self, mime: &str) -> crate::Result<Part> {
    method mime (line 334) | fn mime(self, mime: Mime) -> Part {
    method file_name (line 339) | pub fn file_name<T>(self, filename: T) -> Part
    method headers (line 347) | pub fn headers(self, headers: HeaderMap) -> Part {
    method value_len (line 351) | fn value_len(&self) -> Option<u64> {
    method metadata (line 359) | fn metadata(&self) -> &PartMetadata {
    method with_inner (line 363) | fn with_inner<F>(self, func: F) -> Self
  type PartMetadata (line 34) | struct PartMetadata {
    method new (line 377) | fn new() -> Self {
    method mime (line 385) | fn mime(mut self, mime: Mime) -> Self {
    method file_name (line 390) | fn file_name<T>(mut self, filename: T) -> Self
    method headers (line 398) | fn headers<T>(mut self, headers: T) -> Self
  method default (line 43) | fn default() -> Self {
  constant FRAGMENT_ENCODE_SET (line 408) | const FRAGMENT_ENCODE_SET: &AsciiSet = &percent_encoding::CONTROLS
  constant PATH_ENCODE_SET (line 416) | const PATH_ENCODE_SET: &AsciiSet = &FRAGMENT_ENCODE_SET.add(b'#').add(b'...
  constant PATH_SEGMENT_ENCODE_SET (line 418) | const PATH_SEGMENT_ENCODE_SET: &AsciiSet = &PATH_ENCODE_SET.add(b'/').ad...
  constant ATTR_CHAR_ENCODE_SET (line 421) | const ATTR_CHAR_ENCODE_SET: &AsciiSet = &NON_ALPHANUMERIC
  type PercentEncoding (line 436) | enum PercentEncoding {
    method encode_headers (line 443) | fn encode_headers(&self, name: &str, field: &PartMetadata) -> Vec<u8> {
    method percent_encode (line 488) | fn percent_encode<'a>(&self, value: &'a str) -> Cow<'a, str> {
  function gen_boundary (line 500) | fn gen_boundary() -> String {
  function form_empty (line 550) | fn form_empty() {
  function stream_to_end (line 565) | fn stream_to_end() {
  function stream_to_end_with_header (line 624) | fn stream_to_end_with_header() {
  function correct_content_length (line 656) | fn correct_content_length() {
  function header_percent_encoding (line 679) | fn header_percent_encoding() {
  function custom_boundary_is_applied (line 695) | fn custom_boundary_is_applied() {

FILE: src/client/request.rs
  type Request (line 48) | pub struct Request(http::Request<Option<Body>>);
    method new (line 61) | pub fn new(method: Method, uri: Uri) -> Self {
    method method (line 70) | pub fn method(&self) -> &Method {
    method method_mut (line 76) | pub fn method_mut(&mut self) -> &mut Method {
    method uri (line 82) | pub fn uri(&self) -> &Uri {
    method uri_mut (line 88) | pub fn uri_mut(&mut self) -> &mut Uri {
    method headers (line 94) | pub fn headers(&self) -> &HeaderMap {
    method headers_mut (line 100) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
    method body (line 106) | pub fn body(&self) -> Option<&Body> {
    method body_mut (line 112) | pub fn body_mut(&mut self) -> &mut Option<Body> {
    method version (line 118) | pub fn version(&self) -> Option<Version> {
    method version_mut (line 125) | pub fn version_mut(&mut self) -> &mut Option<Version> {
    method extensions (line 144) | pub fn extensions(&self) -> &Extensions {
    method extensions_mut (line 161) | pub fn extensions_mut(&mut self) -> &mut Extensions {
    method try_clone (line 168) | pub fn try_clone(&self) -> Option<Request> {
    method config (line 182) | pub(crate) fn config<T>(&self) -> Option<&T::Value>
    method config_mut (line 190) | pub(crate) fn config_mut<T>(&mut self) -> &mut Option<T::Value>
    method from (line 893) | fn from(req: http::Request<T>) -> Request {
  type RequestBuilder (line 54) | pub struct RequestBuilder {
    method new (line 199) | pub(super) fn new(client: Client, request: crate::Result<Request>) -> ...
    method from_parts (line 216) | pub fn from_parts(client: Client, request: Request) -> RequestBuilder {
    method header_sensitive (line 224) | fn header_sensitive<K, V>(mut self, key: K, value: V, sensitive: bool)...
    method header (line 259) | pub fn header<K, V>(self, key: K, value: V) -> RequestBuilder
    method headers (line 272) | pub fn headers(mut self, headers: HeaderMap) -> RequestBuilder {
    method orig_headers (line 280) | pub fn orig_headers(mut self, orig_headers: OrigHeaderMap) -> RequestB...
    method default_headers (line 290) | pub fn default_headers(mut self, enable: bool) -> RequestBuilder {
    method auth (line 312) | pub fn auth<V>(self, token: V) -> RequestBuilder
    method basic_auth (line 335) | pub fn basic_auth<U, P>(self, username: U, password: Option<P>) -> Req...
    method bearer_auth (line 359) | pub fn bearer_auth<T: fmt::Display>(self, token: T) -> RequestBuilder {
    method timeout (line 369) | pub fn timeout(mut self, timeout: Duration) -> RequestBuilder {
    method read_timeout (line 383) | pub fn read_timeout(mut self, timeout: Duration) -> RequestBuilder {
    method query (line 412) | pub fn query<T: Serialize + ?Sized>(mut self, query: &T) -> RequestBui...
    method form (line 459) | pub fn form<T: Serialize + ?Sized>(mut self, form: &T) -> RequestBuild...
    method json (line 489) | pub fn json<T: Serialize + ?Sized>(mut self, json: &T) -> RequestBuild...
    method body (line 508) | pub fn body<T: Into<Body>>(mut self, body: T) -> RequestBuilder {
    method multipart (line 532) | pub fn multipart(mut self, mut multipart: multipart::Form) -> RequestB...
    method version (line 561) | pub fn version(mut self, version: Version) -> RequestBuilder {
    method redirect (line 572) | pub fn redirect(mut self, policy: redirect::Policy) -> RequestBuilder {
    method cookie_provider (line 582) | pub fn cookie_provider<C: IntoCookieStore>(mut self, cookie_store: C) ...
    method gzip (line 593) | pub fn gzip(mut self, gzip: bool) -> RequestBuilder {
    method brotli (line 605) | pub fn brotli(mut self, brotli: bool) -> RequestBuilder {
    method deflate (line 617) | pub fn deflate(mut self, deflate: bool) -> RequestBuilder {
    method zstd (line 629) | pub fn zstd(mut self, zstd: bool) -> RequestBuilder {
    method proxy (line 639) | pub fn proxy(mut self, proxy: Proxy) -> RequestBuilder {
    method local_address (line 649) | pub fn local_address<V>(mut self, local_address: V) -> RequestBuilder
    method local_addresses (line 664) | pub fn local_addresses<V4, V6>(mut self, ipv4_address: V4, ipv6_addres...
    method interface (line 738) | pub fn interface<I>(mut self, interface: I) -> RequestBuilder
    method emulation (line 762) | pub fn emulation<T: IntoEmulation>(mut self, emulation: T) -> RequestB...
    method group (line 783) | pub fn group(mut self, group: Group) -> RequestBuilder {
    method build (line 796) | pub fn build(self) -> crate::Result<Request> {
    method build_split (line 806) | pub fn build_split(self) -> (Client, crate::Result<Request>) {
    method send (line 828) | pub fn send(self) -> impl Future<Output = crate::Result<Response>> {
    method try_clone (line 853) | pub fn try_clone(&self) -> Option<RequestBuilder> {
  function extract_authority (line 867) | fn extract_authority(uri: &mut Uri) -> Option<(String, Option<String>)> {
  function from (line 900) | fn from(req: Request) -> http::Request<Body> {

FILE: src/client/response.rs
  type Response (line 30) | pub struct Response {
    method new (line 37) | pub(super) fn new<B>(mut res: http::Response<B>, uri: Uri) -> Response
    method uri (line 54) | pub fn uri(&self) -> &Uri {
    method status (line 60) | pub fn status(&self) -> StatusCode {
    method version (line 66) | pub fn version(&self) -> Version {
    method headers (line 72) | pub fn headers(&self) -> &HeaderMap {
    method headers_mut (line 78) | pub fn headers_mut(&mut self) -> &mut HeaderMap {
    method content_length (line 94) | pub fn content_length(&self) -> Option<u64> {
    method cookies (line 106) | pub fn cookies(&self) -> impl Iterator<Item = cookie::Cookie<'_>> {
    method local_addr (line 116) | pub fn local_addr(&self) -> Option<SocketAddr> {
    method remote_addr (line 124) | pub fn remote_addr(&self) -> Option<SocketAddr> {
    method text (line 162) | pub async fn text(self) -> crate::Result<String> {
    method text_with_charset (line 210) | pub async fn text_with_charset(
    method json (line 275) | pub async fn json<T: DeserializeOwned>(self) -> crate::Result<T> {
    method bytes (line 298) | pub async fn bytes(self) -> crate::Result<Bytes> {
    method bytes_stream (line 331) | pub fn bytes_stream(self) -> impl Stream<Item = crate::Result<Bytes>> {
    method extensions (line 362) | pub fn extensions(&self) -> &http::Extensions {
    method extensions_mut (line 391) | pub fn extensions_mut(&mut self) -> &mut http::Extensions {
    method forbid_recycle (line 405) | pub fn forbid_recycle(&self) {
    method error_for_status (line 432) | pub fn error_for_status(mut self) -> crate::Result<Self> {
    method error_for_status_ref (line 460) | pub fn error_for_status_ref(&self) -> crate::Result<&Self> {
    method upgrade (line 472) | pub async fn upgrade(self) -> crate::Result<Upgraded> {
    method from (line 480) | fn from(r: http::Response<T>) -> Response {
  function from (line 493) | fn from(r: Response) -> http::Response<Body> {
  method from (line 503) | fn from(r: Response) -> Body {
  type Data (line 510) | type Data = Bytes;
  type Error (line 512) | type Error = Error;
  method poll_frame (line 515) | fn poll_frame(
  method is_end_stream (line 523) | fn is_end_stream(&self) -> bool {
  method size_hint (line 528) | fn size_hint(&self) -> http_body::SizeHint {

FILE: src/client/ws.rs
  type WebSocketStream (line 33) | type WebSocketStream = tokio_tungstenite::WebSocketStream<Upgraded>;
  type WebSocketRequestBuilder (line 37) | pub struct WebSocketRequestBuilder {
    method new (line 46) | pub fn new(inner: RequestBuilder) -> Self {
    method accept_key (line 67) | pub fn accept_key<K>(mut self, key: K) -> Self
    method version (line 94) | pub fn version(mut self, version: Version) -> Self {
    method protocols (line 105) | pub fn protocols<P>(mut self, protocols: P) -> Self
    method max_frame_size (line 117) | pub fn max_frame_size(mut self, max_frame_size: usize) -> Self {
    method read_buffer_size (line 124) | pub fn read_buffer_size(mut self, read_buffer_size: usize) -> Self {
    method write_buffer_size (line 131) | pub fn write_buffer_size(mut self, write_buffer_size: usize) -> Self {
    method max_write_buffer_size (line 138) | pub fn max_write_buffer_size(mut self, max_write_buffer_size: usize) -...
    method max_message_size (line 145) | pub fn max_message_size(mut self, max_message_size: usize) -> Self {
    method accept_unmasked_frames (line 152) | pub fn accept_unmasked_frames(mut self, accept_unmasked_frames: bool) ...
    method header (line 161) | pub fn header<K, V>(mut self, key: K, value: V) -> Self
    method headers (line 176) | pub fn headers(mut self, headers: HeaderMap) -> Self {
    method orig_headers (line 183) | pub fn orig_headers(mut self, orig_headers: OrigHeaderMap) -> Self {
    method default_headers (line 191) | pub fn default_headers(mut self, enable: bool) -> Self {
    method auth (line 212) | pub fn auth<V>(mut self, value: V) -> Self
    method basic_auth (line 237) | pub fn basic_auth<U, P>(mut self, username: U, password: Option<P>) ->...
    method bearer_auth (line 262) | pub fn bearer_auth<T>(mut self, token: T) -> Self
    method query (line 291) | pub fn query<T: serde::Serialize + ?Sized>(mut self, query: &T) -> Self {
    method proxy (line 298) | pub fn proxy(mut self, proxy: Proxy) -> Self {
    method local_address (line 305) | pub fn local_address<V>(mut self, local_address: V) -> Self
    method local_addresses (line 315) | pub fn local_addresses<V4, V6>(mut self, ipv4: V4, ipv6: V6) -> Self
    method interface (line 383) | pub fn interface<I>(mut self, interface: I) -> Self
    method emulation (line 402) | pub fn emulation<T: IntoEmulation>(mut self, emulation: T) -> Self {
    method send (line 408) | pub async fn send(self) -> Result<WebSocketResponse, Error> {
  type WebSocketResponse (line 504) | pub struct WebSocketResponse {
    method into_websocket (line 528) | pub async fn into_websocket(self) -> Result<WebSocket, Error> {
  type Target (line 512) | type Target = Response;
  method deref (line 514) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 520) | fn deref_mut(&mut self) -> &mut Self::Target {
  function header_eq (line 622) | fn header_eq(headers: &HeaderMap, key: HeaderName, value: &'static str) ...
  function header_contains (line 631) | fn header_contains(headers: &HeaderMap, key: HeaderName, value: &'static...
  method protocol (line 658) | pub fn protocol(&self) -> Option<&HeaderValue> {
  method recv (line 666) | pub async fn recv(&mut self) -> Option<Result<Message, Error>> {
  method send (line 672) | pub async fn send(&mut self, msg: Message) -> Result<(), Error> {
  method into_inner (line 681) | pub fn into_inner(self) -> Upgraded {
  method close (line 686) | pub async fn close<C, R>(mut self, code: C, reason: R) -> Result<(), Error>
  type Error (line 704) | type Error = Error;
  method poll_ready (line 707) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method start_send (line 715) | fn start_send(self: Pin<&mut Self>, item: Message) -> Result<(), Self::E...
  method poll_flush (line 723) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_close (line 731) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method is_terminated (line 741) | fn is_terminated(&self) -> bool {
  type Item (line 747) | type Item = Result<Message, Error>;
  method poll_next (line 749) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: src/client/ws/json.rs
  method text_from_json (line 18) | pub fn text_from_json<T: Serialize + ?Sized>(json: &T) -> crate::Result<...
  method binary_from_json (line 36) | pub fn binary_from_json<T: Serialize + ?Sized>(json: &T) -> crate::Resul...
  method json (line 57) | pub fn json<T: DeserializeOwned>(&self) -> crate::Result<T> {
  type Content (line 76) | struct Content {
  function text_json (line 81) | pub fn text_json() -> crate::Result<()> {
  function binary_json (line 91) | pub fn binary_json() -> crate::Result<()> {

FILE: src/client/ws/message.rs
  type Utf8Bytes (line 18) | pub struct Utf8Bytes(pub(super) tungstenite::Utf8Bytes);
    method from_static (line 23) | pub const fn from_static(str: &'static str) -> Self {
    method as_str (line 29) | pub fn as_str(&self) -> &str {
    method fmt (line 57) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
    type Error (line 63) | type Error = std::str::Utf8Error;
    method try_from (line 66) | fn try_from(bytes: Bytes) -> Result<Self, Self::Error> {
    type Error (line 72) | type Error = std::str::Utf8Error;
    method try_from (line 75) | fn try_from(v: Vec<u8>) -> Result<Self, Self::Error> {
    method from (line 82) | fn from(s: String) -> Self {
    method from (line 89) | fn from(s: &str) -> Self {
    method from (line 96) | fn from(s: &String) -> Self {
    method eq (line 120) | fn eq(&self, other: &T) -> bool {
  type Target (line 35) | type Target = str;
  method deref (line 50) | fn deref(&self) -> &Self::Target {
  method from (line 103) | fn from(Utf8Bytes(bytes): Utf8Bytes) -> Self {
  type CloseCode (line 127) | pub struct CloseCode(pub(super) u16);
    constant NORMAL (line 136) | pub const NORMAL: CloseCode = CloseCode(1000);
    constant AWAY (line 140) | pub const AWAY: CloseCode = CloseCode(1001);
    constant PROTOCOL (line 143) | pub const PROTOCOL: CloseCode = CloseCode(1002);
    constant UNSUPPORTED (line 150) | pub const UNSUPPORTED: CloseCode = CloseCode(1003);
    constant STATUS (line 153) | pub const STATUS: CloseCode = CloseCode(1005);
    constant ABNORMAL (line 156) | pub const ABNORMAL: CloseCode = CloseCode(1006);
    constant INVALID (line 162) | pub const INVALID: CloseCode = CloseCode(1007);
    constant POLICY (line 170) | pub const POLICY: CloseCode = CloseCode(1008);
    constant SIZE (line 174) | pub const SIZE: CloseCode = CloseCode(1009);
    constant EXTENSION (line 184) | pub const EXTENSION: CloseCode = CloseCode(1010);
    constant ERROR (line 188) | pub const ERROR: CloseCode = CloseCode(1011);
    constant RESTART (line 191) | pub const RESTART: CloseCode = CloseCode(1012);
    constant AGAIN (line 196) | pub const AGAIN: CloseCode = CloseCode(1013);
    method from (line 208) | fn from(code: u16) -> CloseCode {
  function from (line 201) | fn from(code: CloseCode) -> u16 {
  type CloseFrame (line 215) | pub struct CloseFrame {
  type Message (line 246) | pub enum Message {
    method into_tungstenite (line 298) | pub(super) fn into_tungstenite(self) -> tungstenite::Message {
    method from_tungstenite (line 330) | pub(super) fn from_tungstenite(message: tungstenite::Message) -> Optio...
    method into_data (line 348) | pub fn into_data(self) -> Bytes {
    method into_text (line 358) | pub fn into_text(self) -> crate::Result<Utf8Bytes> {
    method to_text (line 371) | pub fn to_text(&self) -> crate::Result<&str> {
    method text (line 385) | pub fn text<S>(string: S) -> Message
    method binary (line 393) | pub fn binary<B>(bin: B) -> Message
    method ping (line 401) | pub fn ping<B>(bin: B) -> Message
    method pong (line 409) | pub fn pong<B>(bin: B) -> Message
    method close (line 417) | pub fn close<C>(close: C) -> Message
    method from (line 426) | fn from(string: String) -> Self {
    method from (line 432) | fn from(string: &'s str) -> Self {
    method from (line 438) | fn from(data: &'b [u8]) -> Self {
    method from (line 444) | fn from(data: Vec<u8>) -> Self {
  function from (line 450) | fn from(msg: Message) -> Self {

FILE: src/config.rs
  type RequestConfigValue (line 33) | pub(crate) trait RequestConfigValue: Clone + 'static {
  type RequestConfig (line 40) | pub(crate) struct RequestConfig<T: RequestConfigValue>(Option<T::Value>);
  method default (line 44) | fn default() -> Self {
  function new (line 55) | pub(crate) const fn new(v: Option<T::Value>) -> Self {
  function as_ref (line 61) | pub(crate) const fn as_ref(&self) -> Option<&T::Value> {
  function fetch (line 70) | pub(crate) fn fetch<'a>(&'a self, ext: &'a Extensions) -> Option<&'a T::...
  function store (line 83) | pub(crate) fn store<'a>(&'a self, ext: &'a mut Extensions) -> &'a mut Op...
  function load (line 93) | pub(crate) fn load(&mut self, ext: &mut Extensions) -> Option<&T::Value> {
  function get (line 105) | pub(crate) fn get(ext: &Extensions) -> Option<&T::Value> {
  function get_mut (line 115) | pub(crate) fn get_mut(ext: &mut Extensions) -> &mut Option<T::Value> {
  function remove (line 123) | pub(crate) fn remove(ext: &mut Extensions) -> Option<T::Value> {

FILE: src/cookie.rs
  type Cookies (line 14) | pub enum Cookies {
  type CookieStore (line 26) | pub trait CookieStore: Send + Sync {
    method set_cookies (line 28) | fn set_cookies(&self, cookie_headers: &mut dyn Iterator<Item = &Header...
    method cookies (line 39) | fn cookies(&self, uri: &Uri, version: Version) -> Cookies;
    method set_cookies (line 414) | fn set_cookies(&self, cookie_headers: &mut dyn Iterator<Item = &Header...
    method cookies (line 425) | fn cookies(&self, uri: &Uri, version: Version) -> Cookies {
  type IntoCookie (line 54) | pub trait IntoCookie {
    method into_cookie (line 56) | fn into_cookie(self) -> Option<Cookie<'static>>;
    method into_cookie (line 75) | fn into_cookie(self) -> Option<Cookie<'static>> {
    method into_cookie (line 82) | fn into_cookie(self) -> Option<Cookie<'static>> {
    method into_cookie (line 89) | fn into_cookie(self) -> Option<Cookie<'static>> {
  type Cookie (line 61) | pub struct Cookie<'a>(RawCookie<'a>);
  type Jar (line 69) | pub struct Jar(RwLock<HashMap<String, HashMap<String, CookieJar>>>);
    method get (line 222) | pub fn get<U: IntoUri>(&self, name: &str, uri: U) -> Option<Cookie<'st...
    method get_all (line 250) | pub fn get_all(&self) -> impl Iterator<Item = Cookie<'static>> {
    method add (line 295) | pub fn add<C, U>(&self, cookie: C, uri: U)
    method remove (line 378) | pub fn remove<C, U>(&self, cookie: C, uri: U)
    method clear (line 408) | pub fn clear(&self) {
  function parse (line 97) | pub(crate) fn parse(value: &'a HeaderValue) -> crate::Result<Cookie<'a>> {
  function name (line 107) | pub fn name(&self) -> &str {
  function value (line 113) | pub fn value(&self) -> &str {
  function http_only (line 119) | pub fn http_only(&self) -> bool {
  function secure (line 125) | pub fn secure(&self) -> bool {
  function same_site_lax (line 131) | pub fn same_site_lax(&self) -> bool {
  function same_site_strict (line 137) | pub fn same_site_strict(&self) -> bool {
  function path (line 143) | pub fn path(&self) -> Option<&str> {
  function domain (line 149) | pub fn domain(&self) -> Option<&str> {
  function max_age (line 155) | pub fn max_age(&self) -> Option<std::time::Duration> {
  function expires (line 161) | pub fn expires(&self) -> Option<SystemTime> {
  function into_owned (line 171) | pub fn into_owned(self) -> Cookie<'static> {
  function fmt (line 178) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function from (line 185) | fn from(cookie: RawCookie<'c>) -> Cookie<'c> {
  function from (line 192) | fn from(cookie: Cookie<'c>) -> RawCookie<'c> {
  constant DEFAULT_PATH (line 496) | const DEFAULT_PATH: &str = "/";
  function domain_match (line 504) | fn domain_match(host: &str, domain: &str) -> bool {
  function path_match (line 524) | fn path_match(req_path: &str, cookie_path: &str) -> bool {
  function normalize_domain (line 536) | fn normalize_domain(domain: &str) -> &str {
  function normalize_path (line 549) | fn normalize_path(path: &str) -> &str {
  function jar_get_all_backfills_domain_and_path (line 569) | fn jar_get_all_backfills_domain_and_path() {
  function jar_get_all_keeps_existing_domain_and_path (line 584) | fn jar_get_all_keeps_existing_domain_and_path() {
  function jar_get_all_backfills_only_missing_field (line 602) | fn jar_get_all_backfills_only_missing_field() {
  function jar_add_rejects_mismatched_domain (line 622) | fn jar_add_rejects_mismatched_domain() {
  function jar_add_accepts_matching_parent_domain (line 630) | fn jar_add_accepts_matching_parent_domain() {
  function jar_get_all_export_import_keeps_effective_path (line 643) | fn jar_get_all_export_import_keeps_effective_path() {
  function cookie_store_invalid_explicit_path_falls_back_to_default_path (line 662) | fn cookie_store_invalid_explicit_path_falls_back_to_default_path() {
  function jar_sends_parent_domain_cookie_to_subdomain (line 675) | fn jar_sends_parent_domain_cookie_to_subdomain() {
  function jar_subdomain_cookie_does_not_leak_to_parent_or_sibling (line 713) | fn jar_subdomain_cookie_does_not_leak_to_parent_or_sibling() {

FILE: src/dns.rs
  type InternalResolve (line 32) | pub trait InternalResolve {
    method poll_ready (line 37) | fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<()...
    method resolve (line 38) | fn resolve(&mut self, name: Name) -> Self::Future;
    type Addrs (line 48) | type Addrs = S::Response;
    type Error (line 49) | type Error = S::Error;
    type Future (line 50) | type Future = S::Future;
    method poll_ready (line 52) | fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<()...
    method resolve (line 56) | fn resolve(&mut self, name: Name) -> Self::Future {
  function resolve (line 61) | pub async fn resolve<R>(resolver: &mut R, name: Name) -> Result<R::Addrs...

FILE: src/dns/gai.rs
  type GaiResolver (line 17) | pub struct GaiResolver {
    method new (line 40) | pub fn new() -> Self {
    type Response (line 46) | type Response = GaiAddrs;
    type Error (line 47) | type Error = io::Error;
    type Future (line 48) | type Future = GaiFuture;
    method poll_ready (line 50) | fn poll_ready(&mut self, _cx: &mut task::Context<'_>) -> Poll<Result<(...
    method call (line 54) | fn call(&mut self, name: Name) -> Self::Future {
  type GaiAddrs (line 22) | pub struct GaiAddrs {
  type GaiFuture (line 27) | pub struct GaiFuture {
  type SocketAddrs (line 32) | pub(crate) struct SocketAddrs {
    method new (line 117) | pub(crate) fn new(addrs: Vec<SocketAddr>) -> Self {
    method try_parse (line 123) | pub(crate) fn try_parse(host: &str, port: u16) -> Option<SocketAddrs> {
    method filter (line 140) | fn filter(self, predicate: impl FnMut(&SocketAddr) -> bool) -> SocketA...
    method split_by_preference (line 144) | pub(crate) fn split_by_preference(
    method is_empty (line 169) | pub(crate) fn is_empty(&self) -> bool {
    method len (line 173) | pub(crate) fn len(&self) -> usize {
  method resolve (line 67) | fn resolve(&self, name: Name) -> Resolving {
  type Output (line 81) | type Output = Result<GaiAddrs, io::Error>;
  method poll (line 83) | fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Se...
  method drop (line 99) | fn drop(&mut self) {
  type Item (line 107) | type Item = SocketAddr;
  method next (line 109) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 179) | type Item = SocketAddr;
  method next (line 181) | fn next(&mut self) -> Option<SocketAddr> {
  function test_ip_addrs_split_by_preference (line 193) | fn test_ip_addrs_split_by_preference() {
  function test_name_from_str (line 243) | fn test_name_from_str() {

FILE: src/dns/hickory.rs
  type HickoryDnsResolver (line 15) | pub struct HickoryDnsResolver {
    method new (line 31) | pub fn new() -> HickoryDnsResolver {
  method resolve (line 57) | fn resolve(&self, name: Name) -> Resolving {

FILE: src/dns/resolve.rs
  type Name (line 16) | pub struct Name {
    method new (line 23) | pub fn new(host: Box<str>) -> Name {
    method as_str (line 29) | pub fn as_str(&self) -> &str {
    method from (line 35) | fn from(value: &str) -> Self {
    method fmt (line 41) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 47) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Addrs (line 53) | pub type Addrs = Box<dyn Iterator<Item = SocketAddr> + Send>;
  type Resolving (line 56) | pub type Resolving = Pin<Box<dyn Future<Output = Result<Addrs, BoxError>...
  type Resolve (line 59) | pub trait Resolve: Send + Sync {
    method resolve (line 72) | fn resolve(&self, name: Name) -> Resolving;
    method resolve (line 137) | fn resolve(&self, name: Name) -> Resolving {
  type DynResolver (line 88) | pub(crate) struct DynResolver {
    method new (line 94) | pub(crate) fn new(resolver: Arc<dyn Resolve>) -> Self {
    type Response (line 100) | type Response = Addrs;
    type Error (line 101) | type Error = BoxError;
    type Future (line 102) | type Future = Resolving;
    method poll_ready (line 104) | fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self:...
    method call (line 108) | fn call(&mut self, name: Name) -> Self::Future {
  type DnsResolverWithOverrides (line 118) | pub(crate) struct DnsResolverWithOverrides {
    method new (line 125) | pub(crate) fn new(

FILE: src/error.rs
  type Result (line 8) | pub type Result<T> = std::result::Result<T, Error>;
  type BoxError (line 11) | pub type BoxError = Box<dyn StdError + Send + Sync>;
  type Error (line 18) | pub struct Error {
    method new (line 43) | fn new<E>(kind: Kind, source: Option<E>) -> Error
    method builder (line 57) | pub(crate) fn builder<E: Into<BoxError>>(e: E) -> Error {
    method body (line 62) | pub(crate) fn body<E: Into<BoxError>>(e: E) -> Error {
    method tls (line 67) | pub(crate) fn tls<E: Into<BoxError>>(e: E) -> Error {
    method decode (line 72) | pub(crate) fn decode<E: Into<BoxError>>(e: E) -> Error {
    method request (line 77) | pub(crate) fn request<E: Into<BoxError>>(e: E) -> Error {
    method redirect (line 82) | pub(crate) fn redirect<E: Into<BoxError>>(e: E, uri: Uri) -> Error {
    method upgrade (line 87) | pub(crate) fn upgrade<E: Into<BoxError>>(e: E) -> Error {
    method websocket (line 93) | pub(crate) fn websocket<E: Into<BoxError>>(e: E) -> Error {
    method status_code (line 98) | pub(crate) fn status_code(uri: Uri, status: StatusCode, reason: Option...
    method uri_bad_scheme (line 103) | pub(crate) fn uri_bad_scheme(uri: Uri) -> Error {
    method uri (line 129) | pub fn uri(&self) -> Option<&Uri> {
    method uri_mut (line 139) | pub fn uri_mut(&mut self) -> Option<&mut Uri> {
    method with_uri (line 145) | pub fn with_uri(mut self, uri: Uri) -> Self {
    method without_uri (line 153) | pub fn without_uri(mut self) -> Self {
    method is_builder (line 160) | pub fn is_builder(&self) -> bool {
    method is_redirect (line 166) | pub fn is_redirect(&self) -> bool {
    method is_status (line 172) | pub fn is_status(&self) -> bool {
    method is_timeout (line 177) | pub fn is_timeout(&self) -> bool {
    method is_request (line 205) | pub fn is_request(&self) -> bool {
    method is_connect (line 210) | pub fn is_connect(&self) -> bool {
    method is_proxy_connect (line 229) | pub fn is_proxy_connect(&self) -> bool {
    method is_connection_reset (line 248) | pub fn is_connection_reset(&self) -> bool {
    method is_body (line 265) | pub fn is_body(&self) -> bool {
    method is_tls (line 271) | pub fn is_tls(&self) -> bool {
    method is_decode (line 277) | pub fn is_decode(&self) -> bool {
    method is_upgrade (line 283) | pub fn is_upgrade(&self) -> bool {
    method is_websocket (line 290) | pub fn is_websocket(&self) -> bool {
    method status (line 295) | pub fn status(&self) -> Option<StatusCode> {
    method fmt (line 328) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 346) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Inner (line 22) | struct Inner {
  type Kind (line 29) | enum Kind {
  function map_timeout_to_connector_error (line 307) | pub(crate) fn map_timeout_to_connector_error(error: BoxError) -> BoxError {
  function map_timeout_to_request_error (line 319) | pub(crate) fn map_timeout_to_request_error(error: BoxError) -> BoxError {
  method source (line 391) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  type TimedOut (line 397) | pub(crate) struct TimedOut;
    method fmt (line 410) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type BadScheme (line 400) | pub(crate) struct BadScheme;
    method fmt (line 420) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ProxyConnect (line 403) | pub(crate) struct ProxyConnect(pub(crate) BoxError);
    method fmt (line 435) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method source (line 429) | fn source(&self) -> Option<&(dyn StdError + 'static)> {
  function assert_send (line 444) | fn assert_send<T: Send>() {}
  function assert_sync (line 445) | fn assert_sync<T: Sync>() {}
  function into_io (line 448) | fn into_io(self) -> io::Error {
  function decode_io (line 453) | fn decode_io(e: io::Error) -> Error {
  function test_source_chain (line 465) | fn test_source_chain() {
  function mem_size_of (line 476) | fn mem_size_of() {
  function roundtrip_io_error (line 482) | fn roundtrip_io_error() {
  function from_unknown_io_error (line 496) | fn from_unknown_io_error() {
  function is_timeout (line 506) | fn is_timeout() {
  function is_connection_reset (line 516) | fn is_connection_reset() {

FILE: src/ext.rs
  constant FRAGMENT (line 10) | const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(...
  constant PATH (line 13) | const PATH: &AsciiSet = &FRAGMENT.add(b'#').add(b'?').add(b'{').add(b'}');
  constant USERINFO (line 16) | const USERINFO: &AsciiSet = &PATH
  type ResponseExt (line 56) | pub trait ResponseExt {
    method uri (line 58) | fn uri(&self) -> Option<&Uri>;
    method uri (line 99) | fn uri(&self) -> Option<&Uri> {
  type ResponseBuilderExt (line 64) | pub trait ResponseBuilderExt {
    method uri (line 67) | fn uri(self, uri: Uri) -> Self;
    method uri (line 107) | fn uri(self, uri: Uri) -> Self {
  type RequestUri (line 72) | pub(crate) struct RequestUri(pub Uri);
  type UriExt (line 75) | pub(crate) trait UriExt {
    method is_http (line 77) | fn is_http(&self) -> bool;
    method is_https (line 80) | fn is_https(&self) -> bool;
    method port_or_default (line 83) | fn port_or_default(&self) -> u16;
    method set_query (line 87) | fn set_query(&mut self, query: String);
    method userinfo (line 90) | fn userinfo(&self) -> (Option<&str>, Option<&str>);
    method set_userinfo (line 93) | fn set_userinfo(&mut self, username: &str, password: Option<&str>);
    method is_http (line 116) | fn is_http(&self) -> bool {
    method is_https (line 121) | fn is_https(&self) -> bool {
    method port_or_default (line 125) | fn port_or_default(&self) -> u16 {
    method set_query (line 134) | fn set_query(&mut self, query: String) {
    method userinfo (line 159) | fn userinfo(&self) -> (Option<&str>, Option<&str>) {
    method set_userinfo (line 170) | fn set_userinfo(&mut self, username: &str, password: Option<&str>) {
  function test_uri_ext_is_https (line 225) | fn test_uri_ext_is_https() {
  function test_userinfo_with_username_and_password (line 236) | fn test_userinfo_with_username_and_password() {
  function test_userinfo_with_empty_username (line 245) | fn test_userinfo_with_empty_username() {
  function test_userinfo_with_empty_password (line 254) | fn test_userinfo_with_empty_password() {
  function test_userinfo_without_colon (line 269) | fn test_userinfo_without_colon() {
  function test_userinfo_without_at (line 278) | fn test_userinfo_without_at() {
  function test_set_userinfo_both (line 287) | fn test_set_userinfo_both() {
  function test_set_userinfo_empty_username (line 298) | fn test_set_userinfo_empty_username() {
  function test_set_userinfo_none_password (line 309) | fn test_set_userinfo_none_password() {
  function test_set_userinfo_empty_username_and_password (line 320) | fn test_set_userinfo_empty_username_and_password() {
  function test_set_userinfo_with_encoding (line 331) | fn test_set_userinfo_with_encoding() {
  function test_set_userinfo_only_username_with_encoding (line 350) | fn test_set_userinfo_only_username_with_encoding() {
  function test_set_userinfo_only_password_with_encoding (line 366) | fn test_set_userinfo_only_password_with_encoding() {
  function test_set_query (line 383) | fn test_set_query() {
  function test_response_builder_ext (line 401) | fn test_response_builder_ext() {
  function test_response_ext (line 413) | fn test_response_ext() {

FILE: src/header.rs
  type IntoOrigHeaderName (line 21) | pub trait IntoOrigHeaderName: sealed::Sealed {
    method into_orig_header_name (line 23) | fn into_orig_header_name(self) -> OrigHeaderName;
    method into_orig_header_name (line 232) | fn into_orig_header_name(self) -> OrigHeaderName {
    method into_orig_header_name (line 239) | fn into_orig_header_name(self) -> OrigHeaderName {
    method into_orig_header_name (line 246) | fn into_orig_header_name(self) -> OrigHeaderName {
    method into_orig_header_name (line 255) | fn into_orig_header_name(self) -> OrigHeaderName {
    method into_orig_header_name (line 264) | fn into_orig_header_name(self) -> OrigHeaderName {
    method into_orig_header_name (line 273) | fn into_orig_header_name(self) -> OrigHeaderName {
    method into_orig_header_name (line 280) | fn into_orig_header_name(self) -> OrigHeaderName {
  type OrigHeaderMap (line 33) | pub struct OrigHeaderMap(HeaderMap<OrigHeaderName>);
    method new (line 40) | pub fn new() -> Self {
    method with_capacity (line 46) | pub fn with_capacity(size: usize) -> Self {
    method insert (line 60) | pub fn insert<N>(&mut self, orig: N) -> bool
    method extend (line 77) | pub fn extend(&mut self, iter: OrigHeaderMap) {
    method len (line 87) | pub fn len(&self) -> usize {
    method is_empty (line 93) | pub fn is_empty(&self) -> bool {
    method iter (line 99) | pub fn iter(&self) -> impl Iterator<Item = (&HeaderName, &OrigHeaderNa...
    method sort_headers (line 107) | pub(crate) fn sort_headers(&self, headers: &mut HeaderMap) {
    method sort_headers_for_each (line 143) | pub(crate) fn sort_headers_for_each<F>(&self, headers: &mut HeaderMap,...
  type Item (line 174) | type Item = (&'a HeaderName, &'a OrigHeaderName);
  type IntoIter (line 175) | type IntoIter = <&'a HeaderMap<OrigHeaderName> as IntoIterator>::IntoIter;
  method into_iter (line 178) | fn into_iter(self) -> Self::IntoIter {
  type Item (line 184) | type Item = (Option<HeaderName>, OrigHeaderName);
  type IntoIter (line 185) | type IntoIter = <HeaderMap<OrigHeaderName> as IntoIterator>::IntoIter;
  method into_iter (line 188) | fn into_iter(self) -> Self::IntoIter {
  type OrigHeaderName (line 208) | pub struct OrigHeaderName {
    method as_ref (line 222) | fn as_ref(&self) -> &[u8] {
  type Kind (line 213) | pub(super) enum Kind {
  type Sealed (line 293) | pub trait Sealed {}
  function get_all (line 313) | pub(crate) fn get_all<'a>(
  function test_header_order (line 321) | fn test_header_order() {
  function test_extend_preserves_order (line 337) | fn test_extend_preserves_order() {
  function test_header_case (line 358) | fn test_header_case() {
  function test_header_multiple_cases (line 373) | fn test_header_multiple_cases() {
  function test_sort_headers_preserves_multiple_cookie_values (line 390) | fn test_sort_headers_preserves_multiple_cookie_values() {
  function test_sort_headers_multiple_values_different_headers (line 462) | fn test_sort_headers_multiple_values_different_headers() {

FILE: src/into_uri.rs
  type IntoUri (line 19) | pub trait IntoUri: IntoUriSealed {}
  type IntoUriSealed (line 29) | pub trait IntoUriSealed {
    method into_uri (line 31) | fn into_uri(self) -> Result<Uri>;
    method into_uri (line 35) | fn into_uri(self) -> Result<Uri> {
    method into_uri (line 43) | fn into_uri(self) -> Result<Uri> {
    method into_uri (line 52) | fn into_uri(self) -> Result<Uri> {
    method into_uri (line 61) | fn into_uri(self) -> Result<Uri> {
    method into_uri (line 68) | fn into_uri(self) -> Result<Uri> {
    method into_uri (line 74) | fn into_uri(self) -> Result<Uri> {
    method into_uri (line 83) | fn into_uri(self) -> Result<Uri> {
  type Kind (line 97) | pub(super) enum Kind<'a> {
  function parse (line 102) | pub(super) fn parse(s: Kind) -> Result<Uri> {
  function into_uri_bad_scheme (line 120) | fn into_uri_bad_scheme() {
  function into_uri_with_space_in_path (line 135) | fn into_uri_with_space_in_path() {
  function into_uri_with_unicode_in_path (line 141) | fn into_uri_with_unicode_in_path() {
  function into_uri_with_special_chars_in_path (line 147) | fn into_uri_with_special_chars_in_path() {
  function into_uri_with_query_preserved (line 153) | fn into_uri_with_query_preserved() {
  function into_uri_bytes_with_encoding (line 161) | fn into_uri_bytes_with_encoding() {
  function test_bytes_with_query (line 168) | fn test_bytes_with_query() {
  function test_bytes_with_unicode (line 175) | fn test_bytes_with_unicode() {
  function test_bytes_minimal (line 182) | fn test_bytes_minimal() {

FILE: src/lib.rs
  function _assert_impls (line 310) | fn _assert_impls() {
  function get (line 356) | pub fn get<T: IntoUri>(uri: T) -> RequestBuilder {
  function post (line 381) | pub fn post<T: IntoUri>(uri: T) -> RequestBuilder {
  function put (line 406) | pub fn put<T: IntoUri>(uri: T) -> RequestBuilder {
  function delete (line 430) | pub fn delete<T: IntoUri>(uri: T) -> RequestBuilder {
  function head (line 454) | pub fn head<T: IntoUri>(uri: T) -> RequestBuilder {
  function patch (line 479) | pub fn patch<T: IntoUri>(uri: T) -> RequestBuilder {
  function options (line 503) | pub fn options<T: IntoUri>(uri: T) -> RequestBuilder {
  function request (line 528) | pub fn request<T: IntoUri>(method: Method, uri: T) -> RequestBuilder {
  function websocket (line 582) | pub fn websocket<T: IntoUri>(uri: T) -> ws::WebSocketRequestBuilder {

FILE: src/proxy.rs
  type Proxy (line 62) | pub struct Proxy {
    method http (line 121) | pub fn http<U: IntoUri>(uri: U) -> crate::Result<Proxy> {
    method https (line 139) | pub fn https<U: IntoUri>(uri: U) -> crate::Result<Proxy> {
    method all (line 160) | pub fn all<U: IntoUri>(uri: U) -> crate::Result<Proxy> {
    method unix (line 179) | pub fn unix<P: uds::IntoUnixSocket>(unix: P) -> crate::Result<Proxy> {
    method new (line 183) | fn new(scheme: ProxyScheme) -> Proxy {
    method basic_auth (line 206) | pub fn basic_auth(mut self, username: &str, password: &str) -> Proxy {
    method custom_http_auth (line 239) | pub fn custom_http_auth(mut self, header_value: HeaderValue) -> Proxy {
    method custom_http_headers (line 259) | pub fn custom_http_headers(mut self, headers: HeaderMap) -> Proxy {
    method no_proxy (line 287) | pub fn no_proxy(mut self, no_proxy: Option<NoProxy>) -> Proxy {
    method into_matcher (line 292) | pub(crate) fn into_matcher(self) -> Matcher {
  type NoProxy (line 70) | pub struct NoProxy {
    method from_env (line 332) | pub fn from_env() -> Option<NoProxy> {
    method from_string (line 363) | pub fn from_string(no_proxy_list: &str) -> Option<Self> {
  type Intercepted (line 78) | pub(crate) enum Intercepted {
  type Matcher (line 85) | pub(crate) struct Matcher {
    method system (line 373) | pub(crate) fn system() -> Self {
    method intercept (line 382) | pub(crate) fn intercept(&self, dst: &Uri) -> Option<Intercepted> {
  type ProxyScheme (line 90) | enum ProxyScheme {
  type Extra (line 99) | struct Extra {
  method hash (line 390) | fn hash<H: Hasher>(&self, state: &mut H) {
  function uri (line 407) | fn uri(s: &str) -> Uri {
  function intercept (line 411) | fn intercept(p: &Matcher, s: &Uri) -> matcher::Intercept {
  function intercepted_uri (line 421) | fn intercepted_uri(p: &Matcher, s: &str) -> Uri {
  function test_http (line 432) | fn test_http() {
  function test_https (line 444) | fn test_https() {
  function test_all (line 456) | fn test_all() {
  function test_standard_with_custom_auth_header (line 471) | fn test_standard_with_custom_auth_header() {
  function test_maybe_has_http_auth (line 484) | fn test_maybe_has_http_auth() {
  function test_maybe_has_http_custom_headers (line 503) | fn test_maybe_has_http_custom_headers() {
  function test_socks_proxy_default_port (line 542) | fn test_socks_proxy_default_port(uri: &str, url2: &str, port: u16) {
  function test_socks4_proxy_default_port (line 559) | fn test_socks4_proxy_default_port() {
  function test_socks5_proxy_default_port (line 565) | fn test_socks5_proxy_default_port() {

FILE: src/proxy/mac.rs
  function with_system (line 16) | pub(super) fn with_system(builder: &mut super::matcher::Builder) {
  function parse_setting_from_dynamic_store (line 50) | fn parse_setting_from_dynamic_store(

FILE: src/proxy/matcher.rs
  type Matcher (line 34) | pub struct Matcher {
    method from_system (line 107) | pub fn from_system() -> Self {
    method builder (line 112) | pub fn builder() -> Builder {
    method intercept (line 120) | pub fn intercept(&self, dst: &Uri) -> Option<Intercepted> {
  type Intercept (line 46) | pub struct Intercept {
    method uri (line 147) | pub(crate) fn uri(&self) -> &Uri {
    method basic_auth (line 151) | pub(crate) fn basic_auth(&self) -> Option<&HeaderValue> {
    method custom_headers (line 164) | pub(crate) fn custom_headers(&self) -> Option<&HeaderMap> {
    method raw_auth (line 169) | pub(crate) fn raw_auth(&self) -> Option<(Bytes, Bytes)> {
  type Builder (line 56) | pub struct Builder {
    method from_env (line 181) | fn from_env() -> Self {
    method from_system (line 193) | fn from_system() -> Self {
    method all (line 207) | pub fn all<S>(mut self, val: S) -> Self
    method http (line 216) | pub fn http<S>(mut self, val: S) -> Self
    method https (line 225) | pub fn https<S>(mut self, val: S) -> Self
    method no (line 251) | pub fn no<S>(mut self, val: S) -> Self
    method unix (line 261) | pub fn unix<S>(mut self, val: S) -> Self
    method build (line 270) | pub(super) fn build(self, extra: Extra) -> Matcher {
  type Auth (line 67) | pub enum Auth {
  type NoProxy (line 77) | struct NoProxy {
    method empty (line 386) | fn empty() -> NoProxy {
    method from_string (line 413) | pub fn from_string(no_proxy_list: &str) -> Self {
    method contains (line 439) | pub fn contains(&self, host: &str) -> bool {
  type DomainMatcher (line 83) | struct DomainMatcher(Vec<String>);
    method contains (line 480) | fn contains(&self, domain: &str) -> bool {
  type IpMatcher (line 86) | struct IpMatcher(Vec<Ip>);
    method contains (line 457) | fn contains(&self, addr: IpAddr) -> bool {
  type Ip (line 89) | enum Ip {
  function get_first_env (line 307) | fn get_first_env(names: &[&str]) -> String {
  function parse_env_uri (line 317) | fn parse_env_uri(val: &str) -> Option<Intercept> {
  type IntoValue (line 518) | pub trait IntoValue {
    method into_value (line 520) | fn into_value(self) -> String;
    method into_value (line 525) | fn into_value(self) -> String {
    method into_value (line 532) | fn into_value(self) -> String {
    method into_value (line 539) | fn into_value(self) -> String {
  function test_domain_matcher (line 550) | fn test_domain_matcher() {
  function test_no_proxy_wildcard (line 574) | fn test_no_proxy_wildcard() {
  function test_no_proxy_ip_ranges (line 580) | fn test_no_proxy_ip_ranges() {
  function intercept (line 637) | fn intercept(p: &Matcher, u: &str) -> Intercept {
  function test_all_proxy (line 648) | fn test_all_proxy() {
  function test_specific_overrides_all (line 659) | fn test_specific_overrides_all() {
  function test_parse_no_scheme_defaults_to_http (line 672) | fn test_parse_no_scheme_defaults_to_http() {
  function test_parse_http_auth (line 686) | fn test_parse_http_auth() {
  function test_parse_http_auth_without_password (line 700) | fn test_parse_http_auth_without_password() {
  function test_parse_http_auth_without_scheme (line 713) | fn test_parse_http_auth_without_scheme() {
  function test_dont_parse_http_when_is_cgi (line 727) | fn test_dont_parse_http_when_is_cgi() {
  function test_parse_socks (line 736) | fn test_parse_socks(uri: &str) {
  function test_parse_socks4 (line 746) | fn test_parse_socks4() {
  function test_parse_socks5 (line 752) | fn test_parse_socks5() {
  function test_domain_matcher_case_insensitive (line 758) | fn test_domain_matcher_case_insensitive() {
  function test_no_proxy_case_insensitive (line 772) | fn test_no_proxy_case_insensitive() {

FILE: src/proxy/uds.rs
  type IntoUnixSocket (line 18) | pub trait IntoUnixSocket: sealed::Sealed {
    method unix_socket (line 20) | fn unix_socket(self) -> Arc<Path>;
    method unix_socket (line 24) | fn unix_socket(self) -> Arc<Path> {
    method unix_socket (line 30) | fn unix_socket(self) -> Arc<Path> {
    method unix_socket (line 36) | fn unix_socket(self) -> Arc<Path> {
    method unix_socket (line 41) | fn unix_socket(self) -> Arc<Path> {
    method unix_socket (line 47) | fn unix_socket(self) -> Arc<Path> {
  type Sealed (line 59) | pub trait Sealed {}

FILE: src/proxy/win.rs
  function with_system (line 1) | pub(super) fn with_system(builder: &mut super::matcher::Builder) {

FILE: src/redirect.rs
  type Policy (line 31) | pub struct Policy {
    method limited (line 116) | pub fn limited(max: usize) -> Self {
    method none (line 124) | pub fn none() -> Self {
    method custom (line 165) | pub fn custom<T>(policy: T) -> Self
    method redirect (line 194) | pub fn redirect(&self, attempt: Attempt) -> Action {
    method check (line 211) | fn check(
  type Attempt (line 39) | pub struct Attempt<'a, const PENDING: bool = true> {
  type Action (line 55) | pub struct Action {
  type History (line 61) | pub struct History(Vec<HistoryEntry>);
  type HistoryEntry (line 66) | pub struct HistoryEntry {
  type PolicyKind (line 81) | enum PolicyKind {
    method fmt (line 335) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type TooManyRedirects (line 88) | struct TooManyRedirects;
    method fmt (line 347) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type FollowRedirectPolicy (line 101) | pub(crate) struct FollowRedirectPolicy {
    method new (line 358) | pub fn new(policy: Policy) -> Self {
    method with_referer (line 370) | pub fn with_referer(mut self, referer: bool) -> Self {
    method with_https_only (line 377) | pub fn with_https_only(mut self, https_only: bool) -> Self {
    method redirect (line 384) | fn redirect(&mut self, attempt: redirect::Attempt<'_>) -> Result<redir...
    method follow_redirects (line 433) | fn follow_redirects(&mut self, request: &mut http::Request<Body>) -> b...
    method on_request (line 439) | fn on_request(&mut self, req: &mut http::Request<Body>) {
    method on_response (line 451) | fn on_response<Body>(&mut self, response: &mut http::Response<Body>) {
    method clone_body (line 458) | fn clone_body(&self, body: &Body) -> Option<Body> {
  method default (line 230) | fn default() -> Policy {
  function follow (line 243) | pub fn follow(self) -> Action {
  function stop (line 253) | pub fn stop(self) -> Action {
  function error (line 263) | pub fn error<E: Into<BoxError>>(self, error: E) -> Action {
  function pending (line 292) | pub fn pending<F, Fut>(self, func: F) -> Action
  type Item (line 313) | type Item = HistoryEntry;
  type IntoIter (line 314) | type IntoIter = std::vec::IntoIter<HistoryEntry>;
  method into_iter (line 317) | fn into_iter(self) -> Self::IntoIter {
  type Item (line 323) | type Item = &'a HistoryEntry;
  type IntoIter (line 324) | type IntoIter = std::slice::Iter<'a, HistoryEntry>;
  method into_iter (line 327) | fn into_iter(self) -> Self::IntoIter {
  function make_referer (line 463) | fn make_referer(next: Uri, previous: &Uri) -> Option<HeaderValue> {
  function remove_sensitive_headers (line 473) | fn remove_sensitive_headers(headers: &mut HeaderMap, next: &Uri, previou...
  function test_redirect_policy_limit (line 497) | fn test_redirect_policy_limit() {
  function test_redirect_policy_limit_to_0 (line 518) | fn test_redirect_policy_limit_to_0() {
  function test_redirect_policy_custom (line 530) | fn test_redirect_policy_custom() {
  function test_remove_sensitive_headers (line 553) | fn test_remove_sensitive_headers() {

FILE: src/retry.rs
  type Policy (line 49) | pub struct Policy {
    method never (line 62) | pub fn never() -> Policy {
    method for_host (line 83) | pub fn for_host<S>(host: S) -> Policy
    method scoped (line 98) | fn scoped<F>(func: F) -> Policy
    method no_budget (line 118) | pub fn no_budget(mut self) -> Self {
    method max_extra_load (line 139) | pub fn max_extra_load(mut self, extra_percent: f32) -> Self {
    method max_retries_per_request (line 158) | pub fn max_retries_per_request(mut self, max: u32) -> Self {
    method classify_fn (line 180) | pub fn classify_fn<F>(mut self, func: F) -> Self
  method default (line 190) | fn default() -> Self {

FILE: src/sync.rs
  type Mutex (line 32) | pub struct Mutex<T: ?Sized>(sync::Mutex<T>);
  function new (line 37) | pub fn new(t: T) -> Mutex<T> {
  function lock (line 45) | pub fn lock<'a>(&'a self) -> MutexGuard<'a, T> {
  type MutexGuard (line 52) | pub struct MutexGuard<'a, T: ?Sized + 'a>(sync::MutexGuard<'a, T>);
  type Target (line 55) | type Target = T;
  method deref (line 58) | fn deref(&self) -> &T {
  method deref_mut (line 65) | fn deref_mut(&mut self) -> &mut T {
  method default (line 71) | fn default() -> Self {
  type RwLock (line 80) | pub struct RwLock<T: ?Sized>(sync::RwLock<T>);
  function read (line 85) | pub fn read<'a>(&'a self) -> RwLockReadGuard<'a, T> {
  function write (line 91) | pub fn write<'a>(&'a self) -> RwLockWriteGuard<'a, T> {
  type RwLockReadGuard (line 98) | pub struct RwLockReadGuard<'a, T: ?Sized + 'a>(sync::RwLockReadGuard<'a,...
  type Target (line 101) | type Target = T;
  method deref (line 104) | fn deref(&self) -> &T {
  type RwLockWriteGuard (line 111) | pub struct RwLockWriteGuard<'a, T: ?Sized + 'a>(sync::RwLockWriteGuard<'...
  type Target (line 114) | type Target = T;
  method deref (line 117) | fn deref(&self) -> &T {
  method deref_mut (line 124) | fn deref_mut(&mut self) -> &mut T {

FILE: src/tls.rs
  type TlsInfo (line 23) | pub struct TlsInfo {
    method peer_certificate (line 30) | pub fn peer_certificate(&self) -> Option<&[u8]> {
    method peer_certificate_chain (line 37) | pub fn peer_certificate_chain(&self) -> Option<impl Iterator<Item = &[...
  type TlsVersion (line 46) | pub struct TlsVersion(btls::ssl::SslVersion);
    constant TLS_1_0 (line 50) | pub const TLS_1_0: TlsVersion = TlsVersion(btls::ssl::SslVersion::TLS1);
    constant TLS_1_1 (line 53) | pub const TLS_1_1: TlsVersion = TlsVersion(btls::ssl::SslVersion::TLS1...
    constant TLS_1_2 (line 56) | pub const TLS_1_2: TlsVersion = TlsVersion(btls::ssl::SslVersion::TLS1...
    constant TLS_1_3 (line 59) | pub const TLS_1_3: TlsVersion = TlsVersion(btls::ssl::SslVersion::TLS1...
  type AlpnProtocol (line 64) | pub struct AlpnProtocol(&'static [u8]);
    constant HTTP1 (line 68) | pub const HTTP1: AlpnProtocol = AlpnProtocol(b"http/1.1");
    constant HTTP2 (line 71) | pub const HTTP2: AlpnProtocol = AlpnProtocol(b"h2");
    constant HTTP3 (line 74) | pub const HTTP3: AlpnProtocol = AlpnProtocol(b"h3");
    method new (line 78) | pub const fn new(value: &'static [u8]) -> Self {
    method encode (line 83) | fn encode(self) -> Bytes {
    method encode_sequence (line 87) | fn encode_sequence<'a, I>(items: I) -> Bytes
  type AlpsProtocol (line 102) | pub struct AlpsProtocol(&'static [u8]);
    constant HTTP1 (line 106) | pub const HTTP1: AlpsProtocol = AlpsProtocol(b"http/1.1");
    constant HTTP2 (line 109) | pub const HTTP2: AlpsProtocol = AlpsProtocol(b"h2");
    constant HTTP3 (line 112) | pub const HTTP3: AlpsProtocol = AlpsProtocol(b"h3");
  type TlsOptionsBuilder (line 118) | pub struct TlsOptionsBuilder {
    method alpn_protocols (line 290) | pub fn alpn_protocols<I>(mut self, alpn: I) -> Self
    method alps_protocols (line 300) | pub fn alps_protocols<I>(mut self, alps: I) -> Self
    method alps_use_new_codepoint (line 310) | pub fn alps_use_new_codepoint(mut self, enabled: bool) -> Self {
    method session_ticket (line 316) | pub fn session_ticket(mut self, enabled: bool) -> Self {
    method min_tls_version (line 323) | pub fn min_tls_version<T>(mut self, version: T) -> Self
    method max_tls_version (line 333) | pub fn max_tls_version<T>(mut self, version: T) -> Self
    method pre_shared_key (line 343) | pub fn pre_shared_key(mut self, enabled: bool) -> Self {
    method enable_ech_grease (line 350) | pub fn enable_ech_grease(mut self, enabled: bool) -> Self {
    method permute_extensions (line 357) | pub fn permute_extensions<T>(mut self, permute: T) -> Self
    method grease_enabled (line 367) | pub fn grease_enabled<T>(mut self, enabled: T) -> Self
    method enable_ocsp_stapling (line 377) | pub fn enable_ocsp_stapling(mut self, enabled: bool) -> Self {
    method enable_signed_cert_timestamps (line 384) | pub fn enable_signed_cert_timestamps(mut self, enabled: bool) -> Self {
    method record_size_limit (line 391) | pub fn record_size_limit<U: Into<Option<u16>>>(mut self, limit: U) -> ...
    method psk_skip_session_ticket (line 398) | pub fn psk_skip_session_ticket(mut self, skip: bool) -> Self {
    method psk_dhe_ke (line 405) | pub fn psk_dhe_ke(mut self, enabled: bool) -> Self {
    method renegotiation (line 412) | pub fn renegotiation(mut self, enabled: bool) -> Self {
    method delegated_credentials (line 419) | pub fn delegated_credentials<T>(mut self, creds: T) -> Self
    method key_shares (line 429) | pub fn key_shares<T>(mut self, key_shares: T) -> Self
    method curves_list (line 439) | pub fn curves_list<T>(mut self, curves: T) -> Self
    method cipher_list (line 449) | pub fn cipher_list<T>(mut self, ciphers: T) -> Self
    method sigalgs_list (line 459) | pub fn sigalgs_list<T>(mut self, sigalgs: T) -> Self
    method certificate_compressors (line 469) | pub fn certificate_compressors<T>(mut self, algs: T) -> Self
    method extension_permutation (line 479) | pub fn extension_permutation<T>(mut self, permutation: T) -> Self
    method aes_hw_override (line 489) | pub fn aes_hw_override<T>(mut self, enabled: T) -> Self
    method random_aes_hw_override (line 499) | pub fn random_aes_hw_override(mut self, enabled: bool) -> Self {
    method preserve_tls13_cipher_list (line 517) | pub fn preserve_tls13_cipher_list<T>(mut self, enabled: T) -> Self
    method build (line 527) | pub fn build(self) -> TlsOptions {
  type TlsOptions (line 134) | pub struct TlsOptions {
    method builder (line 534) | pub fn builder() -> TlsOptionsBuilder {
  method default (line 542) | fn default() -> Self {
  function alpn_protocol_encode (line 579) | fn alpn_protocol_encode() {
  function alpn_protocol_encode_single (line 601) | fn alpn_protocol_encode_single() {

FILE: src/tls/compress.rs
  type Codec (line 21) | pub enum Codec {
    method call (line 55) | fn call(&self, input: &[u8], output: &mut dyn io::Write) -> io::Result...
  type CertificateCompressor (line 35) | pub trait CertificateCompressor: Debug + Sync + Send + 'static {
    method compress (line 37) | fn compress(&self) -> Codec;
    method decompress (line 40) | fn decompress(&self) -> Codec;
    method algorithm (line 43) | fn algorithm(&self) -> CertificateCompressionAlgorithm;
  type Compressor (line 46) | struct Compressor<const ALGORITHM: i32> {
  constant ALGORITHM (line 66) | const ALGORITHM: CertificateCompressionAlgorithm = match ALGORITHM {
  constant CAN_COMPRESS (line 72) | const CAN_COMPRESS: bool = true;
  constant CAN_DECOMPRESS (line 73) | const CAN_DECOMPRESS: bool = true;
  function compress (line 76) | fn compress<W>(&self, input: &[u8], output: &mut W) -> io::Result<()>
  function decompress (line 84) | fn decompress<W>(&self, input: &[u8], output: &mut W) -> io::Result<()>
  function register (line 93) | pub(super) fn register(

FILE: src/tls/conn.rs
  function key_index (line 39) | fn key_index() -> Result<Index<Ssl, Key>, ErrorStack> {
  type HandshakeSettings (line 46) | pub struct HandshakeSettings {
  type HttpsConnector (line 60) | pub struct HttpsConnector<T> {
  type TlsConnectorBuilder (line 66) | pub struct TlsConnectorBuilder {
    method alpn_protocol (line 243) | pub fn alpn_protocol(mut self, protocol: Option<AlpnProtocol>) -> Self {
    method keylog (line 250) | pub fn keylog(mut self, keylog: Option<KeyLog>) -> Self {
    method identity (line 257) | pub fn identity(mut self, identity: Option<Identity>) -> Self {
    method cert_store (line 264) | pub fn cert_store<T>(mut self, cert_store: T) -> Self
    method cert_verification (line 274) | pub fn cert_verification(mut self, enabled: bool) -> Self {
    method min_version (line 281) | pub fn min_version<T>(mut self, version: T) -> Self
    method max_version (line 291) | pub fn max_version<T>(mut self, version: T) -> Self
    method tls_sni (line 301) | pub fn tls_sni(mut self, enabled: bool) -> Self {
    method verify_hostname (line 308) | pub fn verify_hostname(mut self, enabled: bool) -> Self {
    method session_store (line 318) | pub fn session_store(mut self, store: Option<Arc<dyn TlsSessionCache>>...
    method build (line 326) | pub fn build<'a, T>(&self, opts: T) -> crate::Result<TlsConnector>
  type TlsConnector (line 81) | pub struct TlsConnector {
    method builder (line 114) | pub fn builder() -> TlsConnectorBuilder {
    method setup_ssl (line 129) | fn setup_ssl(&self, uri: Uri) -> Result<Ssl, BoxError> {
    method setup_ssl2 (line 137) | fn setup_ssl2(&self, descriptor: ConnectionDescriptor) -> Result<Ssl, ...
    method normalize_host (line 220) | fn normalize_host(host: &str) -> &str {
  function new (line 98) | pub fn new(http: S, tls: TlsConnector) -> HttpsConnector<S> {
  function no_alpn (line 104) | pub fn no_alpn(&mut self) -> &mut Self {
  type MaybeHttpsStream (line 487) | pub enum MaybeHttpsStream<T> {
  type EstablishedConn (line 495) | pub struct EstablishedConn<IO> {
  function as_ref (line 504) | fn as_ref(&self) -> &T {
  function fmt (line 513) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method connected (line 525) | fn connected(&self) -> Connected {
  method poll_read (line 546) | fn poll_read(
  method poll_write (line 563) | fn poll_write(
  method poll_flush (line 575) | fn poll_flush(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<i...
  method poll_shutdown (line 583) | fn poll_shutdown(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Pol...
  method is_write_vectored (line 591) | fn is_write_vectored(&self) -> bool {
  method poll_write_vectored (line 599) | fn poll_write_vectored(
  function new (line 616) | pub fn new(io: IO, descriptor: ConnectionDescriptor) -> EstablishedConn<...

FILE: src/tls/conn/ext.rs
  type SslConnectorBuilderExt (line 14) | pub trait SslConnectorBuilderExt {
    method set_cert_store (line 16) | fn set_cert_store(self, store: Option<&CertStore>) -> crate::Result<Ss...
    method set_cert_verification (line 19) | fn set_cert_verification(self, enable: bool) -> crate::Result<SslConne...
    method set_cert_compressors (line 22) | fn set_cert_compressors(
    method set_cert_store (line 30) | fn set_cert_store(mut self, store: Option<&CertStore>) -> crate::Resul...
    method set_cert_verification (line 41) | fn set_cert_verification(mut self, enable: bool) -> crate::Result<SslC...
    method set_cert_compressors (line 51) | fn set_cert_compressors(

FILE: src/tls/conn/service.rs
  type BoxFuture (line 19) | type BoxFuture<T, E> = Pin<Box<dyn Future<Output = Result<T, E>> + Send>>;
  function perform_handshake (line 21) | async fn perform_handshake<T>(ssl: btls::ssl::Ssl, conn: T) -> Result<Ma...
  type Response (line 37) | type Response = MaybeHttpsStream<T>;
  type Error (line 38) | type Error = BoxError;
  type Future (line 39) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 42) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 46) | fn call(&mut self, uri: Uri) -> Self::Future {
  type Response (line 73) | type Response = MaybeHttpsStream<T>;
  type Error (line 74) | type Error = BoxError;
  type Future (line 75) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 78) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 82) | fn call(&mut self, descriptor: ConnectionDescriptor) -> Self::Future {
  type Response (line 111) | type Response = MaybeHttpsStream<IO>;
  type Error (line 112) | type Error = BoxError;
  type Future (line 113) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 116) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 120) | fn call(&mut self, conn: EstablishedConn<IO>) -> Self::Future {

FILE: src/tls/keylog.rs
  type KeyLog (line 26) | pub struct KeyLog(Option<Arc<Path>>);
    method from_env (line 30) | pub fn from_env() -> KeyLog {
    method from_file (line 40) | pub fn from_file<P: AsRef<Path>>(path: P) -> KeyLog {
    method handle (line 45) | pub(crate) fn handle(self) -> Result<Handle> {
  function normalize_path (line 68) | fn normalize_path<'a, P>(path: P) -> PathBuf

FILE: src/tls/keylog/handle.rs
  type Handle (line 13) | pub struct Handle {
    method new (line 21) | pub fn new(filepath: Arc<Path>) -> Result<Self> {
    method write (line 54) | pub fn write(&self, line: &str) {

FILE: src/tls/session.rs
  type Key (line 25) | pub struct Key(pub(super) ConnectionId);
  type TlsSession (line 29) | pub struct TlsSession(pub(super) SslSession);
    method id (line 79) | pub fn id(&self) -> &[u8] {
    method time (line 85) | pub fn time(&self) -> u64 {
    method timeout (line 93) | pub fn timeout(&self) -> u32 {
    method protocol_version (line 99) | pub fn protocol_version(&self) -> TlsVersion {
    method borrow (line 131) | fn borrow(&self) -> &[u8] {
  type TlsSessionCache (line 39) | pub trait TlsSessionCache: Send + Sync {
    method put (line 41) | fn put(&self, key: Key, session: TlsSession);
    method pop (line 47) | fn pop(&self, key: &Key) -> Option<TlsSession>;
    method put (line 152) | fn put(&self, key: Key, session: TlsSession) {
    method pop (line 182) | fn pop(&self, key: &Key) -> Option<TlsSession> {
  type LruTlsSessionCache (line 64) | pub struct LruTlsSessionCache {
    method new (line 140) | pub fn new(per_host_session_capacity: usize) -> Self {
  type Inner (line 69) | struct Inner {
  method eq (line 117) | fn eq(&self, other: &TlsSession) -> bool {
  method hash (line 124) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: src/tls/trust.rs
  type CertificateInput (line 20) | pub enum CertificateInput<'c> {
  function with_parser (line 28) | pub(crate) fn with_parser<F>(self, parser: F) -> crate::Result<Certificate>
  function from (line 40) | fn from(cert: Certificate) -> Self {
  function from (line 46) | fn from(value: &'c T) -> CertificateInput<'c> {
  type Certificate (line 53) | pub struct Certificate(X509);
    method from_der (line 58) | pub fn from_der<C: AsRef<[u8]>>(cert: C) -> crate::Result<Self> {
    method from_pem (line 64) | pub fn from_pem<C: AsRef<[u8]>>(cert: C) -> crate::Result<Self> {
    method stack_from_pem (line 70) | pub fn stack_from_pem<C: AsRef<[u8]>>(cert: C) -> crate::Result<Vec<Se...

FILE: src/tls/trust/identity.rs
  type Identity (line 11) | pub struct Identity {
    method from_pkcs12_der (line 44) | pub fn from_pkcs12_der(buf: &[u8], pass: &str) -> crate::Result<Identi...
    method from_pkcs8_pem (line 77) | pub fn from_pkcs8_pem(buf: &[u8], key: &[u8]) -> crate::Result<Identit...
    method add_to_tls (line 91) | pub(crate) fn add_to_tls(
  function identity_from_pkcs12_der_invalid (line 114) | fn identity_from_pkcs12_der_invalid() {
  function identity_from_pkcs8_pem_invalid (line 119) | fn identity_from_pkcs8_pem_invalid() {

FILE: src/tls/trust/parse.rs
  function parse_certs (line 6) | pub fn parse_certs<'c, I>(
  function parse_certs_with_stack (line 20) | pub fn parse_certs_with_stack<C, F>(certs: C, parse: F) -> Result<X509St...
  function process_certs (line 31) | pub fn process_certs<I>(iter: I, store: &mut X509StoreBuilder) -> Result...
  function filter_map_certs (line 53) | pub fn filter_map_certs<'c, I>(

FILE: src/tls/trust/store.rs
  type CertStoreBuilder (line 15) | pub struct CertStoreBuilder {
    method add_der_cert (line 24) | pub fn add_der_cert<'c, C>(self, cert: C) -> Self
    method add_pem_cert (line 33) | pub fn add_pem_cert<'c, C>(self, cert: C) -> Self
    method add_der_certs (line 42) | pub fn add_der_certs<'c, I>(self, certs: I) -> Self
    method add_pem_certs (line 52) | pub fn add_pem_certs<'c, I>(self, certs: I) -> Self
    method add_stack_pem_certs (line 61) | pub fn add_stack_pem_certs<C>(mut self, certs: C) -> Self
    method set_default_paths (line 81) | pub fn set_default_paths(mut self) -> Self {
    method build (line 95) | pub fn build(self) -> Result<CertStore> {
    method parse_cert (line 104) | fn parse_cert<'c, C, P>(mut self, cert: C, parser: P) -> Self
    method parse_certs (line 122) | fn parse_certs<'c, I>(mut self, certs: I, parser: fn(&'c [u8]) -> Resu...
  type CertStore (line 151) | pub struct CertStore(Arc<X509Store>);
    method builder (line 158) | pub fn builder() -> CertStoreBuilder {
    method from_der_certs (line 166) | pub fn from_der_certs<'c, C>(certs: C) -> Result<CertStore>
    method from_pem_certs (line 178) | pub fn from_pem_certs<'c, C>(certs: C) -> Result<CertStore>
    method from_pem_stack (line 190) | pub fn from_pem_stack<C>(certs: C) -> Result<CertStore>
    method add_to_tls (line 202) | pub(crate) fn add_to_tls(&self, tls: &mut SslConnectorBuilder) {
  method default (line 208) | fn default() -> Self {

FILE: src/util.rs
  function basic_auth (line 7) | pub(crate) fn basic_auth<U, P>(username: U, password: Option<P>) -> Head...
  function fast_random (line 31) | pub(crate) fn fast_random() -> u64 {
  function replace_headers (line 55) | pub(crate) fn replace_headers(dst: &mut HeaderMap, src: HeaderMap) {
  type Escape (line 84) | pub(crate) struct Escape<'a>(&'a [u8]);
  function new (line 87) | pub(crate) fn new(bytes: &'a [u8]) -> Self {
  function fmt (line 93) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function fmt (line 100) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: tests/badssl.rs
  function test_badssl_modern (line 15) | async fn test_badssl_modern() {
  function test_badssl_self_signed (line 33) | async fn test_badssl_self_signed() {
  constant CURVES_LIST (line 50) | const CURVES_LIST: &str = join!(
  function test_3des_support (line 61) | async fn test_3des_support() -> wreq::Result<()> {
  function test_firefox_7x_100_cipher (line 92) | async fn test_firefox_7x_100_cipher() -> wreq::Result<()> {
  function test_alps_new_endpoint (line 125) | async fn test_alps_new_endpoint() -> wreq::Result<()> {
  function test_aes_hw_override (line 144) | async fn test_aes_hw_override() -> wreq::Result<()> {
  function test_tls_self_signed_cert (line 189) | async fn test_tls_self_signed_cert() {

FILE: tests/brotli.rs
  function brotli_response (line 9) | async fn brotli_response() {
  function brotli_single_byte_chunks (line 14) | async fn brotli_single_byte_chunks() {
  function test_brotli_empty_body (line 19) | async fn test_brotli_empty_body() {
  function test_accept_header_is_not_changed_if_set (line 40) | async fn test_accept_header_is_not_changed_if_set() {
  function test_accept_encoding_header_is_not_changed_if_set (line 65) | async fn test_accept_encoding_header_is_not_changed_if_set() {
  function brotli_case (line 85) | async fn brotli_case(response_size: usize, chunk_size: usize) {
  constant COMPRESSED_RESPONSE_HEADERS (line 146) | const COMPRESSED_RESPONSE_HEADERS: &[u8] = b"HTTP/1.1 200 OK\x0d\x0a\
  constant RESPONSE_CONTENT (line 151) | const RESPONSE_CONTENT: &str = "some message here";
  function brotli_compress (line 153) | fn brotli_compress(input: &[u8]) -> Vec<u8> {
  function test_non_chunked_non_fragmented_response (line 161) | async fn test_non_chunked_non_fragmented_response() {
  function test_chunked_fragmented_response_1 (line 191) | async fn test_chunked_fragmented_response_1() {
  function test_chunked_fragmented_response_2 (line 244) | async fn test_chunked_fragmented_response_2() {
  function test_chunked_fragmented_response_with_extra_bytes (line 298) | async fn test_chunked_fragmented_response_with_extra_bytes() {

FILE: tests/client.rs
  function auto_headers (line 21) | async fn auto_headers() {
  function test_headers_order_with_client (line 80) | async fn test_headers_order_with_client() {
  function test_headers_order_with_request (line 161) | async fn test_headers_order_with_request() {
  function test_overwrite_headers (line 239) | async fn test_overwrite_headers() {
  function donot_set_content_length_0_if_have_no_body (line 337) | async fn donot_set_content_length_0_if_have_no_body() {
  function user_agent (line 360) | async fn user_agent() {
  function response_text (line 380) | async fn response_text() {
  function response_bytes (line 398) | async fn response_bytes() {
  function response_json (line 417) | async fn response_json() {
  function body_pipe_response (line 434) | async fn body_pipe_response() {
  function overridden_dns_resolution_with_gai (line 481) | async fn overridden_dns_resolution_with_gai() {
  function overridden_dns_resolution_with_gai_multiple (line 504) | async fn overridden_dns_resolution_with_gai_multiple() {
  function overridden_dns_resolution_with_hickory_dns (line 539) | async fn overridden_dns_resolution_with_hickory_dns() {
  function overridden_dns_resolution_with_hickory_dns_multiple (line 563) | async fn overridden_dns_resolution_with_hickory_dns_multiple() {
  function add_json_default_content_type_if_not_set_manually (line 598) | fn add_json_default_content_type_if_not_set_manually() {
  function update_json_content_type_if_set_manually (line 614) | fn update_json_content_type_if_set_manually() {
  function test_tls_info (line 627) | async fn test_tls_info() {
  function close_connection_after_idle_timeout (line 654) | async fn close_connection_after_idle_timeout() {
  function http1_reason_phrase (line 677) | async fn http1_reason_phrase() {
  function error_has_url (line 705) | async fn error_has_url() {
  function http1_only (line 716) | async fn http1_only() {
  function http2_only (line 740) | async fn http2_only() {
  function connection_pool_cache (line 764) | async fn connection_pool_cache() {
  function http1_send_case_sensitive_headers (line 800) | async fn http1_send_case_sensitive_headers() {
  function tunnel_includes_proxy_auth_with_multiple_proxies (line 822) | async fn tunnel_includes_proxy_auth_with_multiple_proxies() {
  function skip_default_headers (line 892) | async fn skip_default_headers() {
  function test_client_same_header_values_append (line 940) | async fn test_client_same_header_values_append() {
  function test_client_default_accept_encoding (line 1000) | async fn test_client_default_accept_encoding() {
  function response_trailers (line 1039) | async fn response_trailers() {

FILE: tests/connector_layers.rs
  function non_op_layer (line 12) | async fn non_op_layer() {
  function non_op_layer_with_timeout (line 31) | async fn non_op_layer_with_timeout() {
  function with_connect_timeout_layer_never_returning (line 52) | async fn with_connect_timeout_layer_never_returning() {
  function with_connect_timeout_layer_slow (line 72) | async fn with_connect_timeout_layer_slow() {
  function multiple_timeout_layers_under_threshold (line 94) | async fn multiple_timeout_layers_under_threshold() {
  function multiple_timeout_layers_over_threshold (line 117) | async fn multiple_timeout_layers_over_threshold() {
  function with_concurrency_limit_layer_timeout (line 142) | async fn with_concurrency_limit_layer_timeout() {
  function with_concurrency_limit_layer_success (line 178) | async fn with_concurrency_limit_layer_success() {
  function no_generic_bounds_required_for_client_new (line 217) | async fn no_generic_bounds_required_for_client_new() {

FILE: tests/cookie.rs
  function cookie_response_accessor (line 8) | async fn cookie_response_accessor() {
  function cookie_store_simple (line 76) | async fn cookie_store_simple() {
  function cookie_store_overwrite_existing (line 97) | async fn cookie_store_overwrite_existing() {
  function cookie_store_max_age (line 130) | async fn cookie_store_max_age() {
  function cookie_store_expires (line 146) | async fn cookie_store_expires() {
  function cookie_store_path (line 166) | async fn cookie_store_path() {
  function cookie_store_stores_response_cookie_with_manual_cookie (line 192) | async fn cookie_store_stores_response_cookie_with_manual_cookie() {
  function cookie_request_level_compression (line 223) | async fn cookie_request_level_compression() {

FILE: tests/deflate.rs
  function deflate_response (line 9) | async fn deflate_response() {
  function deflate_single_byte_chunks (line 14) | async fn deflate_single_byte_chunks() {
  function test_deflate_empty_body (line 19) | async fn test_deflate_empty_body() {
  function test_accept_header_is_not_changed_if_set (line 40) | async fn test_accept_header_is_not_changed_if_set() {
  function test_accept_encoding_header_is_not_changed_if_set (line 65) | async fn test_accept_encoding_header_is_not_changed_if_set() {
  function deflate_case (line 85) | async fn deflate_case(response_size: usize, chunk_size: usize) {
  constant COMPRESSED_RESPONSE_HEADERS (line 145) | const COMPRESSED_RESPONSE_HEADERS: &[u8] = b"HTTP/1.1 200 OK\x0d\x0a\
  constant RESPONSE_CONTENT (line 150) | const RESPONSE_CONTENT: &str = "some message here";
  function deflate_compress (line 152) | fn deflate_compress(input: &[u8]) -> Vec<u8> {
  function test_non_chunked_non_fragmented_response (line 159) | async fn test_non_chunked_non_fragmented_response() {
  function test_chunked_fragmented

[
  {
    "path": ".github/FUNDING.yml",
    "chars": 872,
    "preview": "# These are supported funding model platforms\n\ngithub: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [u"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 834,
    "preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Describe the b"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 595,
    "preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Is your fea"
  },
  {
    "path": ".github/compilation-guide/build.yml",
    "chars": 8359,
    "preview": "name: build\n\non:\n  push:\n    branches: [ \"main\" ]\n  pull_request:\n    branches: [ \"main\" ]\n  workflow_dispatch:\n\nenv:\n  "
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 932,
    "preview": "# To get started with Dependabot version updates, you'll need to specify which\n# package ecosystems to update and where "
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 5489,
    "preview": "name: CI\n\non:\n  push:\n    tags: [\"v*\"]\n  pull_request:\n    paths-ignore:\n      - 'docs/**'\n      - '*.md'\n      - '.gith"
  },
  {
    "path": ".gitignore",
    "chars": 782,
    "preview": "# Generated by Cargo\n# will have compiled files and executables\ntarget\nCargo.lock\n*.swp\n.history\n.vscode\n.direnv\nresult\n"
  },
  {
    "path": "Cargo.toml",
    "chars": 8463,
    "preview": "[package]\nname = \"wreq\"\nversion = \"6.0.0-rc.28\"\ndescription = \"An ergonomic Rust HTTP Client with TLS fingerprint\"\nkeywo"
  },
  {
    "path": "LICENSE",
    "chars": 11389,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "README.md",
    "chars": 6044,
    "preview": "# wreq\n\n[![CI](https://github.com/0x676e67/wreq/actions/workflows/ci.yml/badge.svg)](https://github.com/0x676e67/wreq/ac"
  },
  {
    "path": "RELEASE.md",
    "chars": 257023,
    "preview": "## [unreleased]\n\n### Features\n\n- *(cookie)* RFC 9113 compliant cookie handling ([#1106](https://github.com/0x676e67/wreq"
  },
  {
    "path": "bench/http1.rs",
    "chars": 578,
    "preview": "//! HTTP/1.1 benchmark\n\nmod support;\n\nuse std::time::Duration;\n\nuse criterion::{Criterion, criterion_group, criterion_ma"
  },
  {
    "path": "bench/http1_over_tls.rs",
    "chars": 595,
    "preview": "//! HTTP/1.1 over TLS benchmark\n\nmod support;\n\nuse std::time::Duration;\n\nuse criterion::{Criterion, criterion_group, cri"
  },
  {
    "path": "bench/http2.rs",
    "chars": 576,
    "preview": "//! HTTP/2 benchmark\n\nmod support;\n\nuse std::time::Duration;\n\nuse criterion::{Criterion, criterion_group, criterion_main"
  },
  {
    "path": "bench/http2_over_tls.rs",
    "chars": 593,
    "preview": "//! HTTP/2 over TLS benchmark\n\nmod support;\n\nuse std::time::Duration;\n\nuse criterion::{Criterion, criterion_group, crite"
  },
  {
    "path": "bench/support/bench.rs",
    "chars": 3230,
    "preview": "use criterion::Criterion;\n\nuse crate::support::{\n    BoxError, HttpVersion, Tls, client::bench_clients, current_thread_r"
  },
  {
    "path": "bench/support/client.rs",
    "chars": 6802,
    "preview": "use std::{convert::Infallible, net::SocketAddr, sync::Arc};\n\nuse bytes::Bytes;\nuse criterion::{BenchmarkGroup, measureme"
  },
  {
    "path": "bench/support/server.rs",
    "chars": 5724,
    "preview": "use std::{convert::Infallible, io, net::SocketAddr, pin::Pin, sync::Arc, time::Duration};\n\nuse btls::{\n    pkey::PKey,\n "
  },
  {
    "path": "bench/support.rs",
    "chars": 1259,
    "preview": "pub mod bench;\npub mod client;\npub mod server;\n\nuse std::fmt;\n\npub type BoxError = Box<dyn std::error::Error + Send + Sy"
  },
  {
    "path": "cliff.toml",
    "chars": 5072,
    "preview": "# git-cliff ~ configuration file\n# https://git-cliff.org/docs/configuration\n\n[remote.github]\nowner = \"0x676e67\"\nrepo = \""
  },
  {
    "path": "examples/cert_store.rs",
    "chars": 2863,
    "preview": "use std::time::Duration;\n\nuse wreq::{\n    Client,\n    tls::{TlsInfo, trust::CertStore},\n};\n\n/// Certificate Store Exampl"
  },
  {
    "path": "examples/connect_via_lower_priority_tokio_runtime.rs",
    "chars": 9553,
    "preview": "// This example demonstrates how to delegate the connect calls, which contain TLS handshakes,\n// to a secondary tokio ru"
  },
  {
    "path": "examples/emulate.rs",
    "chars": 4001,
    "preview": "use wreq::{\n    Client, Emulation,\n    header::{self, HeaderMap, HeaderValue, OrigHeaderMap},\n    http2::{Http2Options, "
  },
  {
    "path": "examples/form.rs",
    "chars": 416,
    "preview": "// Short example of a POST request with form data.\n//\n// This is using the `tokio` runtime. You'll need the following de"
  },
  {
    "path": "examples/http1_websocket.rs",
    "chars": 1072,
    "preview": "use futures_util::{SinkExt, StreamExt, TryStreamExt};\nuse wreq::{header, ws::message::Message};\n\n#[tokio::main]\nasync fn"
  },
  {
    "path": "examples/http2_websocket.rs",
    "chars": 1268,
    "preview": "//! Run websocket server\n//!\n//! ```not_rust\n//! git clone https://github.com/tokio-rs/axum && cd axum\n//! cargo run -p "
  },
  {
    "path": "examples/json_dynamic.rs",
    "chars": 1160,
    "preview": "//! This example illustrates the way to send and receive arbitrary JSON.\n//!\n//! This is useful for some ad-hoc experime"
  },
  {
    "path": "examples/json_typed.rs",
    "chars": 1221,
    "preview": "//! This example illustrates the way to send and receive statically typed JSON.\n//!\n//! In contrast to the arbitrary JSO"
  },
  {
    "path": "examples/keylog.rs",
    "chars": 432,
    "preview": "use wreq::tls::keylog::KeyLog;\n\n#[tokio::main]\nasync fn main() -> wreq::Result<()> {\n    // Build a client\n    let clien"
  },
  {
    "path": "examples/request_with_emulate.rs",
    "chars": 3871,
    "preview": "use wreq::{\n    Emulation,\n    header::{self, HeaderMap, HeaderValue, OrigHeaderMap},\n    http2::{Http2Options, PseudoId"
  },
  {
    "path": "examples/request_with_interface.rs",
    "chars": 834,
    "preview": "#[cfg(any(\n    target_os = \"android\",\n    target_os = \"fuchsia\",\n    target_os = \"illumos\",\n    target_os = \"ios\",\n    t"
  },
  {
    "path": "examples/request_with_local_address.rs",
    "chars": 383,
    "preview": "use std::net::IpAddr;\n\nuse wreq::redirect::Policy;\n\n#[tokio::main]\nasync fn main() -> wreq::Result<()> {\n    // Use the "
  },
  {
    "path": "examples/request_with_proxy.rs",
    "chars": 311,
    "preview": "use wreq::Proxy;\n\n#[tokio::main]\nasync fn main() -> wreq::Result<()> {\n    // Use the API you're already familiar with\n "
  },
  {
    "path": "examples/request_with_redirect.rs",
    "chars": 621,
    "preview": "use wreq::redirect::Policy;\n\n#[tokio::main]\nasync fn main() -> wreq::Result<()> {\n    // Use the API you're already fami"
  },
  {
    "path": "examples/request_with_version.rs",
    "chars": 345,
    "preview": "use http::Version;\n\n#[tokio::main]\nasync fn main() -> wreq::Result<()> {\n    // Use the API you're already familiar with"
  },
  {
    "path": "examples/tor_socks.rs",
    "chars": 815,
    "preview": "#![deny(warnings)]\n\n// This is using the `tokio` runtime. You'll need the following dependency:\n//\n// `tokio = { version"
  },
  {
    "path": "examples/unix_socket.rs",
    "chars": 842,
    "preview": "#[cfg(unix)]\n#[tokio::main]\nasync fn main() -> wreq::Result<()> {\n    // Create a Unix socket proxy\n    let proxy = wreq"
  },
  {
    "path": "rustfmt.toml",
    "chars": 128,
    "preview": "group_imports = \"StdExternalCrate\"\nimports_granularity = \"Crate\"\nreorder_imports = true\nwrap_comments = true\ncomment_wid"
  },
  {
    "path": "src/client/body.rs",
    "chars": 6347,
    "preview": "use std::{\n    pin::Pin,\n    task::{Context, Poll, ready},\n};\n\nuse bytes::Bytes;\nuse http_body::{Body as HttpBody, SizeH"
  },
  {
    "path": "src/client/conn/connector.rs",
    "chars": 18806,
    "preview": "use std::{\n    borrow::Cow,\n    future::Future,\n    pin::Pin,\n    sync::Arc,\n    task::{Context, Poll},\n    time::Durati"
  },
  {
    "path": "src/client/conn/descriptor.rs",
    "chars": 3998,
    "preview": "use std::{\n    hash::{BuildHasher, Hash, Hasher},\n    num::NonZeroU64,\n    sync::{\n        Arc, LazyLock,\n        atomic"
  },
  {
    "path": "src/client/conn/http.rs",
    "chars": 16083,
    "preview": "use std::{\n    future::Future,\n    marker::PhantomData,\n    net::{Ipv4Addr, Ipv6Addr, SocketAddr},\n    pin::Pin,\n    syn"
  },
  {
    "path": "src/client/conn/proxy/socks.rs",
    "chars": 6997,
    "preview": "use std::{\n    borrow::Cow,\n    task::{Context, Poll},\n};\n\nuse bytes::Bytes;\nuse http::Uri;\nuse tokio::io::{AsyncRead, A"
  },
  {
    "path": "src/client/conn/proxy/tunnel.rs",
    "chars": 6876,
    "preview": "use std::{\n    marker::{PhantomData, Unpin},\n    task::{self, Poll},\n};\n\nuse bytes::BytesMut;\nuse http::{HeaderMap, Head"
  },
  {
    "path": "src/client/conn/proxy.rs",
    "chars": 977,
    "preview": "//! Proxy helpers\n\n#[cfg(feature = \"socks\")]\npub mod socks;\npub mod tunnel;\n\nuse std::{\n    marker::PhantomData,\n    pin"
  },
  {
    "path": "src/client/conn/tcp/tokio.rs",
    "chars": 1444,
    "preview": "use std::{future::Future, io, net::SocketAddr, pin::Pin, time::Duration};\n\nuse tokio::net::{TcpSocket, TcpStream};\n\nuse "
  },
  {
    "path": "src/client/conn/tcp.rs",
    "chars": 21461,
    "preview": "pub mod tokio;\n\n#[cfg(any(\n    target_os = \"illumos\",\n    target_os = \"ios\",\n    target_os = \"macos\",\n    target_os = \"s"
  },
  {
    "path": "src/client/conn/tls_info.rs",
    "chars": 2407,
    "preview": "use bytes::Bytes;\nuse tokio::net::TcpStream;\n#[cfg(unix)]\nuse tokio::net::UnixStream;\nuse tokio_btls::SslStream;\n\nuse cr"
  },
  {
    "path": "src/client/conn/uds.rs",
    "chars": 1141,
    "preview": "use std::{\n    io,\n    path::Path,\n    pin::Pin,\n    sync::Arc,\n    task::{Context, Poll},\n};\n\nuse http::Uri;\nuse tokio:"
  },
  {
    "path": "src/client/conn/verbose.rs",
    "chars": 4472,
    "preview": "use super::AsyncConnWithInfo;\n\n/// Controls whether to enable verbose tracing for connections.\n///\n/// When enabled (wit"
  },
  {
    "path": "src/client/conn.rs",
    "chars": 13116,
    "preview": "mod connector;\nmod http;\nmod proxy;\nmod tcp;\nmod tls_info;\n#[cfg(unix)]\nmod uds;\nmod verbose;\n\npub mod descriptor;\n\nuse "
  },
  {
    "path": "src/client/core/body/incoming.rs",
    "chars": 15109,
    "preview": "use std::{\n    fmt,\n    pin::Pin,\n    task::{Context, Poll, ready},\n};\n\nuse bytes::Bytes;\nuse http::HeaderMap;\nuse http_"
  },
  {
    "path": "src/client/core/body/length.rs",
    "chars": 3663,
    "preview": "use std::fmt;\n\nuse crate::client::core::error::Parse;\n\n#[derive(Clone, Copy, PartialEq, Eq)]\npub(crate) struct DecodedLe"
  },
  {
    "path": "src/client/core/body/watch.rs",
    "chars": 1864,
    "preview": "//! An SPSC broadcast channel.\n//!\n//! - The value can only be a `u8`.\n//! - The consumer is only notified if the value "
  },
  {
    "path": "src/client/core/body.rs",
    "chars": 1222,
    "preview": "//! Streaming bodies for Requests and Responses\n//!\n//! For both [Clients](crate::client), requests and\n//! responses us"
  },
  {
    "path": "src/client/core/conn/http1.rs",
    "chars": 10012,
    "preview": "//! HTTP/1 client connections\n\nuse std::{\n    future::Future,\n    pin::Pin,\n    task::{Context, Poll, ready},\n};\n\nuse by"
  },
  {
    "path": "src/client/core/conn/http2.rs",
    "chars": 8866,
    "preview": "//! HTTP/2 client connections\n\nuse std::{\n    future::Future,\n    marker::PhantomData,\n    pin::Pin,\n    sync::Arc,\n    "
  },
  {
    "path": "src/client/core/conn.rs",
    "chars": 348,
    "preview": "//! Lower-level client connection API.\n//!\n//! The types in this module are to provide a lower-level API based around a\n"
  },
  {
    "path": "src/client/core/dispatch.rs",
    "chars": 8979,
    "preview": "use std::{\n    future::Future,\n    pin::Pin,\n    task::{Context, Poll},\n};\n\nuse http::{Request, Response};\nuse http_body"
  },
  {
    "path": "src/client/core/error.rs",
    "chars": 13537,
    "preview": "//! Error and Result module.\nuse std::{error::Error as StdError, fmt};\n\n/// Result type often returned from methods that"
  },
  {
    "path": "src/client/core/proto/headers.rs",
    "chars": 4049,
    "preview": "use bytes::BytesMut;\nuse http::{\n    HeaderMap, Method,\n    header::{CONTENT_LENGTH, HeaderValue, ValueIter},\n};\n\n#[inli"
  },
  {
    "path": "src/client/core/proto/http1/buf.rs",
    "chars": 4415,
    "preview": "use std::{collections::VecDeque, io::IoSlice};\n\nuse bytes::{Buf, BufMut, Bytes, BytesMut};\n\n/// A list of buffers that i"
  },
  {
    "path": "src/client/core/proto/http1/conn.rs",
    "chars": 32112,
    "preview": "use std::{\n    fmt, io,\n    marker::{PhantomData, Unpin},\n    pin::Pin,\n    task::{Context, Poll, ready},\n};\n\nuse bytes:"
  },
  {
    "path": "src/client/core/proto/http1/decode.rs",
    "chars": 39877,
    "preview": "use std::{\n    error::Error as StdError,\n    fmt, io,\n    task::{Context, Poll, ready},\n};\n\nuse bytes::{BufMut, Bytes, B"
  },
  {
    "path": "src/client/core/proto/http1/dispatch.rs",
    "chars": 27542,
    "preview": "use std::{\n    convert::Infallible,\n    future::Future,\n    marker::Unpin,\n    pin::Pin,\n    task::{Context, Poll, ready"
  },
  {
    "path": "src/client/core/proto/http1/encode.rs",
    "chars": 17999,
    "preview": "use std::{collections::HashSet, fmt, io::IoSlice};\n\nuse bytes::{\n    Buf, Bytes,\n    buf::{Chain, Take},\n};\nuse http::{\n"
  },
  {
    "path": "src/client/core/proto/http1/ext.rs",
    "chars": 1154,
    "preview": "//! HTTP extensions.\n\nuse bytes::Bytes;\n\n/// A reason phrase in an HTTP/1 response.\n///\n/// # Clients\n///\n/// For client"
  },
  {
    "path": "src/client/core/proto/http1/io.rs",
    "chars": 27328,
    "preview": "use std::{\n    cmp,\n    fmt::{self, Debug},\n    io::{self, IoSlice},\n    pin::Pin,\n    task::{Context, Poll, ready},\n};\n"
  },
  {
    "path": "src/client/core/proto/http1/role.rs",
    "chars": 24263,
    "preview": "use std::{\n    fmt::{self, Write as _},\n    mem::MaybeUninit,\n};\n\nuse bytes::{Bytes, BytesMut};\nuse http::{\n    Method, "
  },
  {
    "path": "src/client/core/proto/http1.rs",
    "chars": 8368,
    "preview": "//! HTTP/1 protocol implementation and utilities.\n\nmod buf;\nmod decode;\nmod encode;\nmod io;\n\npub(crate) mod conn;\npub(cr"
  },
  {
    "path": "src/client/core/proto/http2/client.rs",
    "chars": 21003,
    "preview": "use std::{\n    convert::Infallible,\n    future::Future,\n    marker::PhantomData,\n    pin::Pin,\n    task::{Context, Poll,"
  },
  {
    "path": "src/client/core/proto/http2/ping.rs",
    "chars": 15478,
    "preview": "//! HTTP2 Ping usage\n//!\n//! core uses HTTP2 pings for two purposes:\n//!\n//! 1. Adaptive flow control using BDP\n//! 2. C"
  },
  {
    "path": "src/client/core/proto/http2.rs",
    "chars": 31215,
    "preview": "//! HTTP/2 protocol implementation and utilities.\n\npub(crate) mod client;\npub(crate) mod ping;\n\nuse std::{\n    future::F"
  },
  {
    "path": "src/client/core/proto.rs",
    "chars": 1571,
    "preview": "//! Pieces pertaining to the HTTP message protocol.\n\nmod headers;\n\npub mod http1;\npub mod http2;\n\n/// A request line of "
  },
  {
    "path": "src/client/core/rt/bounds.rs",
    "chars": 1719,
    "preview": "//! Trait aliases\n//!\n//! Traits in this module ease setting bounds and usually automatically\n//! implemented by impleme"
  },
  {
    "path": "src/client/core/rt/timer.rs",
    "chars": 3200,
    "preview": "//! Provides a timer trait with timer-like functions\n\nuse std::{\n    any::TypeId,\n    future::Future,\n    pin::Pin,\n    "
  },
  {
    "path": "src/client/core/rt/tokio.rs",
    "chars": 2297,
    "preview": "//! Tokio IO integration for core.\nuse std::{\n    future::Future,\n    pin::Pin,\n    task::{Context, Poll},\n    time::{Du"
  },
  {
    "path": "src/client/core/rt.rs",
    "chars": 560,
    "preview": "//! Runtime components\n//!\n//! The traits and types within this module are used to allow plugging in\n//! runtime types. "
  },
  {
    "path": "src/client/core/upgrade.rs",
    "chars": 11628,
    "preview": "//! HTTP Upgrades\n//!\n//! This module deals with managing [HTTP Upgrades][mdn] in crate::core:. Since\n//! several concep"
  },
  {
    "path": "src/client/core.rs",
    "chars": 409,
    "preview": "//! Core HTTP client protocol and utilities.\n//!\n//! Much of this codebase is adapted and refined from [hyper](https://g"
  },
  {
    "path": "src/client/emulate.rs",
    "chars": 3208,
    "preview": "use http::HeaderMap;\n\nuse super::{\n    core::{http1::Http1Options, http2::Http2Options},\n    group::Group,\n};\nuse crate:"
  },
  {
    "path": "src/client/future.rs",
    "chars": 2305,
    "preview": "use std::{\n    pin::Pin,\n    task::{Context, Poll, ready},\n};\n\nuse http::{Request, Uri};\nuse pin_project_lite::pin_proje"
  },
  {
    "path": "src/client/group.rs",
    "chars": 5636,
    "preview": "//! # Request Grouping Mechanism\n//!\n//! This module provides the [`Group`] structure, which defines the logical boundar"
  },
  {
    "path": "src/client/layer/client/exec.rs",
    "chars": 692,
    "preview": "use std::{future::Future, pin::Pin, sync::Arc};\n\nuse crate::client::core::rt::Executor;\n\npub(crate) type BoxSendFuture ="
  },
  {
    "path": "src/client/layer/client/lazy.rs",
    "chars": 1721,
    "preview": "use std::{\n    future::Future,\n    pin::Pin,\n    task::{self, Poll},\n};\n\nuse pin_project_lite::pin_project;\n\npub(crate) "
  },
  {
    "path": "src/client/layer/client/pool.rs",
    "chars": 35289,
    "preview": "use std::{\n    collections::{HashMap, HashSet, VecDeque},\n    convert::Infallible,\n    error::Error as StdError,\n    fmt"
  },
  {
    "path": "src/client/layer/client.rs",
    "chars": 42618,
    "preview": "//! Much of this codebase is adapted and refined from [hyper](https://github.com/hyperium/hyper-util),\n\nmod exec;\nmod la"
  },
  {
    "path": "src/client/layer/config.rs",
    "chars": 4097,
    "preview": "use std::{\n    sync::Arc,\n    task::{Context, Poll},\n};\n\nuse futures_util::future::{self, Either, Ready};\nuse http::{Hea"
  },
  {
    "path": "src/client/layer/decoder.rs",
    "chars": 3845,
    "preview": "//! Middleware for decoding\n\nuse std::task::{Context, Poll};\n\nuse http::{Request, Response};\nuse http_body::Body;\nuse to"
  },
  {
    "path": "src/client/layer/redirect/future.rs",
    "chars": 9107,
    "preview": "use std::{\n    future::Future,\n    pin::Pin,\n    str,\n    task::{Context, Poll, ready},\n};\n\nuse futures_util::future::Ei"
  },
  {
    "path": "src/client/layer/redirect/policy.rs",
    "chars": 2501,
    "preview": "//! Tools for customizing the behavior of a [`FollowRedirect`][super::FollowRedirect] middleware.\n\nuse std::{fmt, pin::P"
  },
  {
    "path": "src/client/layer/redirect.rs",
    "chars": 3814,
    "preview": "//! Middleware for following redirections.\n\nmod future;\nmod policy;\n\nuse std::{\n    mem,\n    task::{Context, Poll},\n};\n\n"
  },
  {
    "path": "src/client/layer/retry/classify.rs",
    "chars": 3068,
    "preview": "use std::{error::Error as StdError, sync::Arc};\n\nuse http::{Method, StatusCode, Uri};\n\nuse super::{Req, Res};\nuse crate:"
  },
  {
    "path": "src/client/layer/retry/scope.rs",
    "chars": 1521,
    "preview": "use std::sync::Arc;\n\nuse super::Req;\n\npub trait Scope: Send + Sync + 'static {\n    fn applies_to(&self, req: &super::Req"
  },
  {
    "path": "src/client/layer/retry.rs",
    "chars": 4682,
    "preview": "//! Middleware for retrying requests.\n\nmod classify;\nmod scope;\n\nuse std::{error::Error as StdError, future::Ready, sync"
  },
  {
    "path": "src/client/layer/timeout/body.rs",
    "chars": 6754,
    "preview": "use std::{\n    future::Future,\n    pin::Pin,\n    task::{Context, Poll, ready},\n    time::Duration,\n};\n\nuse http_body::Bo"
  },
  {
    "path": "src/client/layer/timeout/future.rs",
    "chars": 2644,
    "preview": "use std::{\n    future::Future,\n    pin::Pin,\n    task::{Context, Poll, ready},\n    time::Duration,\n};\n\nuse http::Respons"
  },
  {
    "path": "src/client/layer/timeout.rs",
    "chars": 5313,
    "preview": "//! Middleware for setting a timeout on the response.\n\nmod body;\nmod future;\n\nuse std::{\n    sync::Arc,\n    task::{Conte"
  },
  {
    "path": "src/client/layer.rs",
    "chars": 239,
    "preview": "//! Middleware for the client.\n\npub mod client;\npub mod config;\n#[cfg(any(\n    feature = \"gzip\",\n    feature = \"zstd\",\n "
  },
  {
    "path": "src/client/multipart.rs",
    "chars": 22888,
    "preview": "//! multipart/form-data\n\nuse std::{borrow::Cow, pin::Pin};\n\nuse bytes::Bytes;\nuse futures_util::{Stream, StreamExt, futu"
  },
  {
    "path": "src/client/request.rs",
    "chars": 28915,
    "preview": "use std::{\n    convert::TryFrom,\n    fmt,\n    future::Future,\n    net::{IpAddr, Ipv4Addr, Ipv6Addr},\n    time::Duration,"
  },
  {
    "path": "src/client/response.rs",
    "chars": 16245,
    "preview": "use std::{\n    net::SocketAddr,\n    pin::Pin,\n    task::{Context, Poll},\n};\n\nuse bytes::Bytes;\n#[cfg(feature = \"charset\""
  },
  {
    "path": "src/client/ws/json.rs",
    "chars": 3065,
    "preview": "use serde::{Serialize, de::DeserializeOwned};\n\nuse super::{Message, Utf8Bytes};\nuse crate::Error;\n\nimpl Message {\n    //"
  },
  {
    "path": "src/client/ws/message.rs",
    "chars": 15629,
    "preview": "//! WebSocket message types and utilities\n//!\n//! This module provides WebSocket message types that wrap the underlying\n"
  },
  {
    "path": "src/client/ws.rs",
    "chars": 24540,
    "preview": "//! WebSocket Upgrade\n\n#[cfg(feature = \"json\")]\nmod json;\npub mod message;\n\nuse std::{\n    borrow::Cow,\n    fmt,\n    net"
  },
  {
    "path": "src/client.rs",
    "chars": 55157,
    "preview": "mod body;\nmod conn;\nmod core;\nmod emulate;\nmod group;\nmod request;\nmod response;\n\npub mod future;\npub mod layer;\n#[cfg(f"
  },
  {
    "path": "src/config.rs",
    "chars": 5519,
    "preview": "//! The `config` module provides a generic mechanism for loading and managing\n//! request-scoped configuration.\n//!\n//! "
  },
  {
    "path": "src/cookie.rs",
    "chars": 24121,
    "preview": "//! HTTP Cookies\n\nuse std::{collections::HashMap, convert::TryInto, fmt, sync::Arc, time::SystemTime};\n\nuse bytes::Bytes"
  },
  {
    "path": "src/dns/gai.rs",
    "chars": 7131,
    "preview": "use std::{\n    future::Future,\n    io,\n    net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAdd"
  },
  {
    "path": "src/dns/hickory.rs",
    "chars": 2614,
    "preview": "//! DNS resolution via the [hickory-resolver](https://github.com/hickory-dns/hickory-dns) crate\n\nuse std::{net::SocketAd"
  },
  {
    "path": "src/dns/resolve.rs",
    "chars": 4442,
    "preview": "use std::{\n    borrow::Cow,\n    collections::HashMap,\n    fmt,\n    future::Future,\n    net::SocketAddr,\n    pin::Pin,\n  "
  },
  {
    "path": "src/dns.rs",
    "chars": 2030,
    "preview": "//! DNS resolution\n\npub(crate) mod gai;\n#[cfg(feature = \"hickory-dns\")]\npub(crate) mod hickory;\npub(crate) mod resolve;\n"
  },
  {
    "path": "src/error.rs",
    "chars": 14247,
    "preview": "use std::{error::Error as StdError, fmt, io};\n\nuse http::Uri;\n\nuse crate::{StatusCode, client::http1::ext::ReasonPhrase,"
  },
  {
    "path": "src/ext.rs",
    "chars": 12969,
    "preview": "//! Extension utilities.\n\nuse bytes::Bytes;\nuse http::uri::{Authority, Scheme, Uri};\nuse percent_encoding::{AsciiSet, CO"
  },
  {
    "path": "src/header.rs",
    "chars": 16300,
    "preview": "//! HTTP header types\n//!\n//! This module provides [`HeaderName`], [`HeaderMap`], [`OrigHeaderMap`], [`OrigHeaderName`],"
  },
  {
    "path": "src/into_uri.rs",
    "chars": 5214,
    "preview": "//! URI conversion utilities.\n//!\n//! This module provides the [`IntoUri`] trait, allowing various types\n//! (such as `&"
  },
  {
    "path": "src/lib.rs",
    "chars": 17548,
    "preview": "#![deny(unused)]\n#![deny(unsafe_code)]\n#![deny(missing_docs)]\n#![cfg_attr(test, deny(warnings))]\n#![cfg_attr(not(test), "
  },
  {
    "path": "src/proxy/mac.rs",
    "chars": 2532,
    "preview": "use system_configuration::{\n    core_foundation::{\n        base::CFType,\n        dictionary::CFDictionary,\n        numbe"
  },
  {
    "path": "src/proxy/matcher.rs",
    "chars": 24167,
    "preview": "//! Proxy matchers\n//!\n//! This module contains different matchers to configure rules for when a proxy\n//! should be use"
  },
  {
    "path": "src/proxy/uds.rs",
    "chars": 1597,
    "preview": "use std::{\n    path::{Path, PathBuf},\n    sync::Arc,\n};\n\n/// Trait for converting various types into a shared Unix Domai"
  },
  {
    "path": "src/proxy/win.rs",
    "chars": 860,
    "preview": "pub(super) fn with_system(builder: &mut super::matcher::Builder) {\n    let Ok(settings) = windows_registry::CURRENT_USER"
  },
  {
    "path": "src/proxy.rs",
    "chars": 17468,
    "preview": "#[cfg(all(target_os = \"macos\", feature = \"system-proxy\"))]\nmod mac;\n#[cfg(unix)]\nmod uds;\n#[cfg(all(windows, feature = \""
  },
  {
    "path": "src/redirect.rs",
    "chars": 18205,
    "preview": "//! Redirect Handling\n//!\n//! By default, a `Client` does not follow HTTP redirects. To enable automatic\n//! redirect ha"
  },
  {
    "path": "src/retry.rs",
    "chars": 6593,
    "preview": "//! Retry requests\n//!\n//! A `Client` has the ability to retry requests, by sending additional copies\n//! to the server "
  },
  {
    "path": "src/sync.rs",
    "chars": 3708,
    "preview": "//! Synchronization primitives: [`Mutex`] and [`RwLock`] that never poison.\n//!\n//! These types expose APIs identical to"
  },
  {
    "path": "src/tls/compress.rs",
    "chars": 4275,
    "preview": "//! TLS certificate compression [RFC 8879](https://datatracker.ietf.org/doc/html/rfc8879).\n//!\n//! Reduces handshake lat"
  },
  {
    "path": "src/tls/conn/ext.rs",
    "chars": 1949,
    "preview": "use std::borrow::Cow;\n\nuse btls::ssl::{SslConnectorBuilder, SslVerifyMode};\n\nuse crate::{\n    Error,\n    tls::{\n        "
  },
  {
    "path": "src/tls/conn/macros.rs",
    "chars": 871,
    "preview": "macro_rules! set_bool {\n    ($cfg:expr, $field:ident, $conn:expr, $setter:ident) => {\n        if $cfg.$field {\n         "
  },
  {
    "path": "src/tls/conn/service.rs",
    "chars": 4056,
    "preview": "use std::{\n    fmt::Debug,\n    future::Future,\n    pin::Pin,\n    task::{Context, Poll},\n};\n\nuse http::{Uri, uri::Scheme}"
  },
  {
    "path": "src/tls/conn.rs",
    "chars": 18730,
    "preview": "//! SSL support via BoringSSL.\n\n#[macro_use]\nmod macros;\nmod ext;\nmod service;\n\nuse std::{\n    borrow::Cow,\n    fmt::{se"
  },
  {
    "path": "src/tls/keylog/handle.rs",
    "chars": 1696,
    "preview": "use std::{\n    fs::OpenOptions,\n    io::{Result, Write},\n    path::Path,\n    sync::{\n        Arc,\n        mpsc::{self, S"
  },
  {
    "path": "src/tls/keylog.rs",
    "chars": 2975,
    "preview": "//! TLS Key Log Management\n//!\n//! This module provides utilities for managing TLS key logging, allowing session keys to"
  },
  {
    "path": "src/tls/session.rs",
    "chars": 6565,
    "preview": "//! TLS session caching and resumption.\n//!\n//! Handshakes are expensive. This module lets you reuse sessions to save\n//"
  },
  {
    "path": "src/tls/trust/identity.rs",
    "chars": 4475,
    "preview": "use btls::{\n    pkcs12::Pkcs12,\n    pkey::{PKey, Private},\n    x509::X509,\n};\n\nuse crate::Error;\n\n/// Represents a priva"
  },
  {
    "path": "src/tls/trust/parse.rs",
    "chars": 1881,
    "preview": "use btls::x509::store::{X509Store, X509StoreBuilder};\n\nuse super::{Certificate, CertificateInput};\nuse crate::{Error, Re"
  },
  {
    "path": "src/tls/trust/store.rs",
    "chars": 6730,
    "preview": "use std::sync::Arc;\n\nuse btls::{\n    ssl::SslConnectorBuilder,\n    x509::store::{X509Store, X509StoreBuilder},\n};\n\nuse s"
  },
  {
    "path": "src/tls/trust.rs",
    "chars": 1997,
    "preview": "//! TLS Trust and Identity management.\n//!\n//! Handles server certificate verification, mTLS identity, and CA\n//! bundle"
  },
  {
    "path": "src/tls.rs",
    "chars": 18518,
    "preview": "//!  TLS options configuration\n//!\n//! - Various parts of TLS can also be configured or even disabled on the `ClientBuil"
  },
  {
    "path": "src/trace.rs",
    "chars": 990,
    "preview": "macro_rules! debug {\n    ($($arg:tt)+) => {\n        {\n            #[cfg(feature = \"tracing\")]\n            {\n            "
  },
  {
    "path": "src/util.rs",
    "chars": 3468,
    "preview": "use std::{fmt, fmt::Write};\n\nuse bytes::Bytes;\n\nuse crate::header::{Entry, HeaderMap, HeaderValue, OccupiedEntry};\n\npub("
  },
  {
    "path": "tests/badssl.rs",
    "chars": 6072,
    "preview": "use std::time::Duration;\n\nuse wreq::{\n    Client,\n    tls::{AlpsProtocol, TlsInfo, TlsOptions, TlsVersion, trust::CertSt"
  },
  {
    "path": "tests/brotli.rs",
    "chars": 11151,
    "preview": "mod support;\nuse std::io::Read;\n\nuse support::server;\nuse tokio::io::AsyncWriteExt;\nuse wreq::Client;\n\n#[tokio::test]\nas"
  },
  {
    "path": "tests/client.rs",
    "chars": 33758,
    "preview": "mod support;\n\n#[cfg(feature = \"json\")]\nuse std::collections::HashMap;\n\nuse bytes::Bytes;\nuse http::{\n    HeaderMap, Head"
  },
  {
    "path": "tests/connector_layers.rs",
    "chars": 6596,
    "preview": "mod support;\n\nuse std::time::Duration;\n\nuse futures_util::future::join_all;\nuse pretty_env_logger::env_logger;\nuse suppo"
  },
  {
    "path": "tests/cookie.rs",
    "chars": 9386,
    "preview": "mod support;\n\nuse http::{Version, header::COOKIE};\nuse support::server;\nuse wreq::{Client, cookie::Jar};\n\n#[tokio::test]"
  },
  {
    "path": "tests/deflate.rs",
    "chars": 11153,
    "preview": "mod support;\nuse std::io::Write;\n\nuse flate2::{Compression, write::ZlibEncoder};\nuse support::server;\nuse tokio::io::Asy"
  },
  {
    "path": "tests/emulate.rs",
    "chars": 10791,
    "preview": "use std::{\n    io::{self, Write},\n    time::Duration,\n};\n\nuse brotli::{CompressorWriter as BrotliEncoder, Decompressor a"
  },
  {
    "path": "tests/gzip.rs",
    "chars": 11068,
    "preview": "mod support;\nuse std::io::Write;\n\nuse flate2::{Compression, write::GzEncoder};\nuse support::server;\nuse tokio::io::Async"
  },
  {
    "path": "tests/layers.rs",
    "chars": 7218,
    "preview": "mod support;\n\nuse std::time::Duration;\n\nuse futures_util::future::join_all;\nuse pretty_env_logger::env_logger;\nuse suppo"
  },
  {
    "path": "tests/multipart.rs",
    "chars": 5932,
    "preview": "mod support;\nuse http_body_util::BodyExt;\nuse pretty_env_logger::env_logger;\nuse support::server;\n\n#[tokio::test]\nasync "
  },
  {
    "path": "tests/proxy.rs",
    "chars": 11827,
    "preview": "mod support;\nuse std::{env, sync::LazyLock};\n\nuse support::server;\nuse tokio::sync::Mutex;\nuse wreq::Client;\n\n// seriali"
  },
  {
    "path": "tests/redirect.rs",
    "chars": 19316,
    "preview": "mod support;\nuse http::StatusCode;\nuse http_body_util::BodyExt;\nuse support::server;\nuse wreq::{\n    Body, Client,\n    r"
  },
  {
    "path": "tests/retry.rs",
    "chars": 3972,
    "preview": "mod support;\n\nuse std::sync::{\n    Arc,\n    atomic::{AtomicUsize, Ordering},\n};\n\nuse support::server;\nuse wreq::Client;\n"
  },
  {
    "path": "tests/support/crl.pem",
    "chars": 617,
    "preview": "-----BEGIN X509 CRL-----\nMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADANMQswCQYDVQQDDAJjYRcNMjQwOTI2\nMDA0MjU1WhcNMjQxMDI2MDA0MjU1Wj"
  },
  {
    "path": "tests/support/delay_server.rs",
    "chars": 4656,
    "preview": "#![allow(unused)]\nuse std::{convert::Infallible, future::Future, net, time::Duration};\n\nuse futures_util::FutureExt;\nuse"
  },
  {
    "path": "tests/support/error.rs",
    "chars": 374,
    "preview": "use std::error::Error as StdError;\n\n#[allow(unused)]\npub fn inspect<E>(err: E) -> Vec<String>\nwhere\n    E: Into<Box<dyn "
  },
  {
    "path": "tests/support/layer.rs",
    "chars": 4505,
    "preview": "use std::{\n    future::Future,\n    pin::Pin,\n    task::{Context, Poll},\n    time::Duration,\n};\n\nuse futures::future::Box"
  },
  {
    "path": "tests/support/mod.rs",
    "chars": 253,
    "preview": "pub mod delay_server;\npub mod error;\npub mod layer;\npub mod server;\n\n// TODO: remove once done converting to new support"
  },
  {
    "path": "tests/support/server.rs",
    "chars": 7723,
    "preview": "use std::{\n    convert::Infallible, future::Future, io, net, sync::mpsc as std_mpsc, thread, time::Duration,\n};\n\nuse tok"
  },
  {
    "path": "tests/timeouts.rs",
    "chars": 7352,
    "preview": "mod support;\nuse std::time::Duration;\n\nuse pretty_env_logger::env_logger;\nuse support::server;\nuse wreq::Client;\n\n#[toki"
  },
  {
    "path": "tests/unix_socket.rs",
    "chars": 5216,
    "preview": "#![cfg(unix)]\n\nuse std::{hash::BuildHasher, time::Duration};\n\nuse http::Method;\nuse http_body_util::Full;\nuse hyper::{Re"
  },
  {
    "path": "tests/upgrade.rs",
    "chars": 2970,
    "preview": "mod support;\nuse http::Method;\nuse support::server;\nuse tokio::io::{AsyncReadExt, AsyncWriteExt};\nuse wreq::Client;\n\n#[t"
  },
  {
    "path": "tests/zstd.rs",
    "chars": 19477,
    "preview": "mod support;\nuse support::server;\nuse tokio::io::AsyncWriteExt;\nuse wreq::Client;\n\n#[tokio::test]\nasync fn zstd_response"
  }
]

// ... and 2 more files (download for full content)