httpx

type APIError struct {
	StatusCode int            `json:"status_code,omitempty"`
	Code       string         `json:"code,omitempty"`
	Message    string         `json:"message,omitempty"`
	Details    map[string]any `json:"details,omitempty"`
	RequestID  string         `json:"request_id,omitempty"`
	RawBody    []byte         `json:"-"`
	Err        error          `json:"-"`
}

type AuthenticationError struct{ *APIError }

type AuthorizationError struct{ *APIError }

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

type CircuitBreakerConfig struct {
	Enabled          bool
	FailureThreshold int
	SuccessThreshold int
	Timeout          time.Duration
}

type CircuitBreakerMetrics struct {
	State           CircuitState
	FailureCount    int
	SuccessCount    int
	LastStateChange time.Time
}

type CircuitBreakerOpenError struct{ *APIError }

type CircuitState int

type Config struct {
	BaseURL          string
	APIKey           string
	AccessToken      string
	RefreshToken     string
	AdminKey         string
	UserAgent        string
	Headers          map[string]string
	Timeout          time.Duration
	Retry            RetryConfig
	CircuitBreaker   CircuitBreakerConfig
	Logger           Logger
	AutoRefreshToken bool
}

type ConflictError struct{ *APIError }

type Logger interface {
	Debug(msg string, keysAndValues ...any)
}

type NetworkError struct{ *APIError }

type NotFoundError struct{ *APIError }

type PayloadTooLargeError struct{ *APIError }

type QuotaInfo struct {
	// Resource is the limited resource, e.g. "active_jobs" or "queues".
	Resource string
	// Current is the usage that tripped the limit.
	Current int64
	// Limit is the plan limit for Resource.
	Limit int64
	// Plan is the organization's plan tier.
	Plan string
	// UpgradeTo is the plan that lifts the limit, when the API names one.
	UpgradeTo string
}

type RateLimitError struct {
	*APIError
	RetryAfter time.Duration
	Limit      int
	Remaining  int
	Reset      time.Time
	// Quota is set when the 429 is a plan-limit rejection rather than a rate limit.
	Quota *QuotaInfo
	// Scope is the limit Limit, Remaining and Reset describe:
	// "organization" (the plan's request rate) or "api_key" (the key's own
	// per-minute limit). Empty when the header is absent.
	Scope string
}

type Request struct {
	Method string
	Path   string
	Body   any
	// RawBody, when set, is sent verbatim as the request body (skips JSON marshalling of Body).
	// Useful for webhook ingestion endpoints that require signature verification over the exact bytes.
	RawBody     []byte
	Query       map[string]string
	Headers     map[string]string
	UseAdminKey bool
	Idempotent  bool // If true, can be retried for POST
	// SkipCircuitBreaker sends the request even while the breaker is open and
	// keeps its outcome out of the breaker's accounting. It is for worker acks
	// (complete, fail, heartbeat): they are lease-fenced and idempotent, and
	// dropping a finished job's result because an unrelated call tripped the
	// breaker loses work the server would happily accept.
	SkipCircuitBreaker bool
}

type Response struct {
	StatusCode int
	Body       []byte
	Headers    http.Header
	RequestID  string
}

type RetryConfig struct {
	MaxRetries int
	BaseDelay  time.Duration
	MaxDelay   time.Duration
	Factor     float64
	Jitter     bool
}

type RetryPolicy struct {
	MaxRetries int
	BaseDelay  time.Duration
	MaxDelay   time.Duration
	Factor     float64
	Jitter     bool
}

type ServerError struct{ *APIError }

type TimeoutError struct {
	*APIError
	TimeoutSeconds float64
}

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

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

type ValidationError struct{ *APIError }