httpx

type Attempt struct {
	Response *Response
	Err      error
	Duration time.Duration
	Wait     time.Duration
}

type BodySource interface {
	Open() (r io.ReadCloser, length int64, contentType string, err error)
}

type Client struct {
	// contains filtered or unexported fields
}

type FormField struct{ Name, Value string }

type Hop struct {
	Status   int
	URL      string // the URL that answered with the redirect
	Location string
	Header   http.Header
	// Forwarded names the credential headers sent on to Location even
	// though it is another origin (RedirectCredentials, RedirectKeepHeaders).
	Forwarded []string
}

type Jar struct {
	// contains filtered or unexported fields
}

type Options struct {
	// Transport, when set, sends every attempt instead of the network: a run played back from a recording.
	Transport       http.RoundTripper
	Version         string // auto | 1.1 | 2 | h2c | 3
	FollowRedirects bool
	MaxRedirects    int
	// RedirectCredentials says when a redirect may carry credential headers
	// to a new origin: "strip" (the default, and "" means the same) drops
	// them when the origin changes, "same_site" drops them only when the
	// registrable domain changes or https falls back to http, "keep" never
	// drops them. RedirectKeepHeaders names headers that are forwarded
	// whatever the mode.
	RedirectCredentials string
	RedirectKeepHeaders []string
	Timeout             time.Duration // per attempt
	Proxy               *httpproxy.Config
	CAFiles             []string
	ClientCert          *tls.Certificate // sent when the server asks for one (mutual TLS)
	RequestCompression  string           // none | gzip
	Jar                 http.CookieJar   // nil sends and keeps no cookies
	StreamThreshold     int64            // bodies larger than this stream to DownloadDir
	DownloadDir         string
	Retry               RetryPolicy
	Clock               func() time.Time // nil → time.Now
	Rand                *rand.Rand       // retry jitter; nil → runtime-seeded
	// BeforeAttempt and AfterAttempt, when set, are called around each
	// attempt (n is 0-based) on the goroutine calling Do, for live progress.
	BeforeAttempt func(n int)
	AfterAttempt  func(n int, a Attempt)
	// Gate, when set, is called before each attempt with the target host
	// and must return before the attempt starts; release is called when
	// the attempt ends. Waiting in Gate (for a concurrency slot or a rate
	// limit) does not count toward Timeout. An error stops Do.
	Gate func(ctx context.Context, host string) (release func(), err error)
	// contains filtered or unexported fields
}

type OutsideRootError struct{ Path string }

type Part struct {
	Name, Value       string
	File, ContentType string
}

type Request struct {
	Method string
	URL    string
	Header http.Header
	Body   BodySource // nil sends no body
}

type Response struct {
	Status    int
	Proto     string // "HTTP/1.1", "HTTP/2.0"
	Header    http.Header
	Body      []byte // decoded; nil when streamed to File
	File      string // where a streamed body was written
	SHA256    string // hex digest of the decoded body
	RawSize   int64  // bytes on the wire
	Size      int64  // decoded bytes
	Encoding  string // Content-Encoding that was decoded; "" if none or unknown
	Redirects []Hop
	Timings   Timings
}

type RetryPolicy struct {
	Max     int      // extra attempts; 0 = no retries
	Backoff string   // exponential | constant
	Jitter  bool     // full jitter: a random delay in [0, computed]
	On      []string // 5xx | 429 | timeout | connection
	// contains filtered or unexported fields
}

type StoredCookie struct {
	URL    string      `json:"url"`
	Cookie http.Cookie `json:"cookie"`
}

type TimeoutError struct{ After time.Duration }

type Timings struct {
	DNS, Connect, TLS, TTFB, Total time.Duration
}