http

type AuthHeaders struct {
	Verify    map[string]string
	Settle    map[string]string
	Supported map[string]string
	Discovery map[string]string
}

type AuthProvider interface {
	// GetAuthHeaders returns authentication headers for each endpoint
	GetAuthHeaders(ctx context.Context) (AuthHeaders, error)
}

type CompiledRoute struct {
	Verb    string
	Regex   *regexp.Regexp
	Config  RouteConfig
	Pattern string
}

type DynamicPayToFunc func(context.Context, HTTPRequestContext) (string, error)

type DynamicPriceFunc func(context.Context, HTTPRequestContext) (x402.Price, error)

type EVMPaywallHandler struct{}

type FacilitatorConfig struct {
	// URL is the base URL of the facilitator service
	URL string

	// HTTPClient is the HTTP client to use (optional)
	HTTPClient *http.Client

	// AuthProvider provides authentication headers (optional)
	AuthProvider AuthProvider

	// Timeout for requests (optional, defaults to 30s)
	Timeout time.Duration

	// Identifier for this facilitator (optional)
	Identifier string
}

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

type HTTPAdapter interface {
	GetHeader(name string) string
	GetMethod() string
	GetPath() string
	GetURL() string
	GetAcceptHeader() string
	GetUserAgent() string
}

type HTTPClient = x402HTTPClient

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

type HTTPProcessResult struct {
	Type                string
	Response            *HTTPResponseInstructions
	PaymentPayload      *types.PaymentPayload      // V2 only
	PaymentRequirements *types.PaymentRequirements // V2 only
}

type HTTPRequestContext struct {
	Adapter       HTTPAdapter
	Path          string
	Method        string
	PaymentHeader string
	RoutePattern  string
}

type HTTPResponseInstructions struct {
	Status  int               `json:"status"`
	Headers map[string]string `json:"headers"`
	Body    interface{}       `json:"body,omitempty"`
	IsHTML  bool              `json:"isHtml,omitempty"`
}

type HTTPServer = x402HTTPResourceServer

type HTTPTransportContext struct {
	Request         *HTTPRequestContext
	ResponseBody    []byte
	ResponseHeaders http.Header
}

type PaymentOption struct {
	Scheme            string                 `json:"scheme"`
	PayTo             interface{}            `json:"payTo"` // string or DynamicPayToFunc
	Price             interface{}            `json:"price"` // x402.Price or DynamicPriceFunc
	Network           x402.Network           `json:"network"`
	MaxTimeoutSeconds int                    `json:"maxTimeoutSeconds,omitempty"`
	Extra             map[string]interface{} `json:"extra,omitempty"`
}

type PaymentOptions = []PaymentOption

type PaymentRoundTripper struct {
	Transport http.RoundTripper
	// contains filtered or unexported fields
}

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

type PaywallConfig struct {
	AppName    string `json:"appName,omitempty"`
	AppLogo    string `json:"appLogo,omitempty"`
	CurrentURL string `json:"currentUrl,omitempty"`
	Testnet    bool   `json:"testnet,omitempty"`
}

type PaywallNetworkHandler interface {
	// Supports returns true if this handler can generate HTML for the given payment requirement.
	Supports(requirement types.PaymentRequirements) bool

	// GenerateHTML generates the paywall HTML for the given requirement.
	GenerateHTML(requirement types.PaymentRequirements, paymentRequired types.PaymentRequired, config *PaywallConfig) string
}

type PaywallProvider interface {
	GenerateHTML(paymentRequired types.PaymentRequired, config *PaywallConfig) string
}

type ProcessSettleResult struct {
	Success     bool
	Headers     map[string]string
	ErrorReason string
	Transaction string
	Network     x402.Network
	Payer       string
	// Response contains HTTP instructions for the failure case (status 402, body, etc).
	// Set when Success is false; nil when Success is true.
	Response *HTTPResponseInstructions
}

type ProtectedRequestHook func(ctx context.Context, reqCtx HTTPRequestContext, routeConfig RouteConfig) (*ProtectedRequestHookResult, error)

type ProtectedRequestHookResult struct {
	// GrantAccess bypasses payment and grants free access to the resource.
	GrantAccess bool
	// Abort denies the request with a 403 status and the provided Reason.
	Abort  bool
	Reason string
}

type RouteConfig struct {
	// Payment options for this route
	Accepts PaymentOptions `json:"accepts"`

	// HTTP-specific metadata
	Resource          string                 `json:"resource,omitempty"`
	Description       string                 `json:"description,omitempty"`
	MimeType          string                 `json:"mimeType,omitempty"`
	CustomPaywallHTML string                 `json:"customPaywallHtml,omitempty"`
	Extensions        map[string]interface{} `json:"extensions,omitempty"`

	// UnpaidResponseBody is an optional callback to generate a custom response for unpaid API requests.
	// For browser requests (Accept: text/html), the paywall HTML takes precedence.
	// If not provided, defaults to { ContentType: "application/json", Body: nil }.
	UnpaidResponseBody UnpaidResponseBodyFunc `json:"-"`
}

type RouteConfigurationError struct {
	// Errors contains all validation failures
	Errors []RouteValidationError
}

type RouteValidationError struct {
	// RoutePattern is the route pattern (e.g., "GET /api/weather")
	RoutePattern string

	// Scheme is the payment scheme that failed validation
	Scheme string

	// Network is the network that failed validation
	Network x402.Network

	// Reason is the type of validation failure: "missing_scheme" or "missing_facilitator"
	Reason string

	// Message is a human-readable error message
	Message string
}

type RoutesConfig map[string]RouteConfig

type SVMPaywallHandler struct{}

type UnpaidResponse struct {
	// ContentType is the content type for the response (e.g., "application/json", "text/plain").
	ContentType string

	// Body is the response body to include in the 402 response.
	Body interface{}
}

type UnpaidResponseBodyFunc func(ctx context.Context, reqCtx HTTPRequestContext) (*UnpaidResponse, error)