transport

type ConnStats struct {
	Host           string
	CreatedAt      time.Time
	LastUsedAt     time.Time
	UseCount       int64
	Age            time.Duration
	IdleTime       time.Duration
	IsReused       bool
	SessionResumed bool   // True if TLS session was resumed
	TLSVersion     uint16 // TLS version (e.g., 0x0304 for TLS 1.3)
	CipherSuite    uint16 // Negotiated cipher suite
}

type ErrorCallback func(operation string, key string, err error)

type HTTP1ConnStats struct {
	IdleConns      int
	TotalUseCount  int64
	OldestCreated  time.Time
	NewestLastUsed time.Time
}

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

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

type HTTP3Stats struct {
	RequestCount int64
	DialCount    int64 // Number of new connections created
	Reusing      bool  // True if connections are being reused
}

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

type HTTPError struct {
	StatusCode int
	Status     string
	Body       []byte
	Headers    map[string]string
}

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

type Protocol int

type ProxyConfig struct {
	URL      string // Proxy URL (e.g., "http://proxy:8080" or "http://user:pass@proxy:8080")
	Username string // Proxy username (optional, can also be in URL)
	Password string // Proxy password (optional, can also be in URL)

	// TCPProxy is the proxy URL for TCP-based protocols (HTTP/1.1 and HTTP/2)
	// When set, overrides URL for TCP transports
	TCPProxy string

	// UDPProxy is the proxy URL for UDP-based protocols (HTTP/3 via MASQUE)
	// When set, overrides URL for UDP transports
	UDPProxy string
}

type RedirectInfo struct {
	StatusCode int
	URL        string
	Headers    map[string][]string // Multi-value headers
}

type Request struct {
	Method     string
	URL        string
	Headers    map[string][]string // Multi-value headers (matches http.Header)
	Body       []byte
	BodyReader io.Reader // For streaming uploads - used instead of Body if set
	Timeout    time.Duration
}

type Response struct {
	StatusCode int
	Headers    map[string][]string // Multi-value headers (matches http.Header)
	Body       io.ReadCloser       // Streaming body - call Close() when done
	FinalURL   string
	Timing     *protocol.Timing
	Protocol   string // "h1", "h2", or "h3"
	History    []*RedirectInfo
	// contains filtered or unexported fields
}

type SessionCacheBackend interface {
	// Get retrieves a TLS session for the given key.
	// Returns nil, nil if not found.
	// Returns nil, error if backend error (will be propagated to caller).
	Get(ctx context.Context, key string) (*TLSSessionState, error)

	// Put stores a TLS session with the given TTL.
	// TTL should typically be ~24 hours (TLS session ticket lifetime).
	// Returns error if backend error (will be propagated to caller).
	Put(ctx context.Context, key string, session *TLSSessionState, ttl time.Duration) error

	// Delete removes a session from the cache.
	// Returns error if backend error.
	Delete(ctx context.Context, key string) error

	// GetECHConfig retrieves ECH config for a host (required for HTTP/3).
	// Returns nil, nil if not found.
	GetECHConfig(ctx context.Context, key string) ([]byte, error)

	// PutECHConfig stores ECH config for a host.
	PutECHConfig(ctx context.Context, key string, config []byte, ttl time.Duration) error
}

type StreamResponse struct {
	StatusCode int
	Headers    map[string][]string // Multi-value headers
	FinalURL   string
	Timing     *protocol.Timing
	Protocol   string // "h1", "h2", or "h3"

	// ContentLength is the expected total size (-1 if unknown/chunked)
	ContentLength int64
	// contains filtered or unexported fields
}

type TLSSessionState struct {
	Ticket    string    `json:"ticket"` // base64 encoded
	State     string    `json:"state"`  // base64 encoded
	CreatedAt time.Time `json:"created_at"`
}

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

type TransportConfig struct {
	// ConnectTo maps request hosts to connection hosts (domain fronting).
	// Key: request host, Value: connection host for DNS resolution
	ConnectTo map[string]string

	// ECHConfig is a custom ECH configuration (overrides DNS fetch)
	ECHConfig []byte

	// ECHConfigDomain is a domain to fetch ECH config from instead of target
	ECHConfigDomain string

	// TLSOnly mode: use TLS fingerprint but skip preset HTTP headers
	// User sets all headers manually
	TLSOnly bool

	// QuicIdleTimeout is the idle timeout for QUIC connections (default: 30s)
	QuicIdleTimeout time.Duration

	// SessionCacheBackend is an optional distributed cache for TLS sessions.
	// When set, TLS session tickets will be stored/retrieved from this backend,
	// enabling session sharing across multiple instances.
	SessionCacheBackend SessionCacheBackend

	// SessionCacheErrorCallback is called when backend operations fail.
	// This is optional but recommended for monitoring backend health.
	SessionCacheErrorCallback ErrorCallback
}

type TransportError struct {
	Op        string // Operation that failed (e.g., "dial", "tls_handshake", "request")
	Host      string // Target host
	Port      string // Target port
	Protocol  string // Protocol (h1, h2, h3)
	Cause     error  // Underlying error
	Category  error  // Error category (ErrConnection, ErrTLS, etc.)
	Retryable bool   // Whether the operation can be retried
}