genericapi

type APIAgentRouteFinder interface {
	FindTokenRoute(tokenID uint, model string) *models.AgentRoute
	FindAPIRouteRoute(routeID uint) *models.AgentRoute
	FindAPIServiceRoute(serviceID uint) *models.AgentRoute
}

type APIBreakerCompletion struct {
	Result      *apiattempt.APIExecutionResult
	Err         error
	ClientAbort APIClientAbortReason
}

type APIBreakerFinder interface {
	Healthy(upstreamID uint) bool
	TryAcquire(upstreamID uint) (APIBreakerPermit, bool)
}

type APIBreakerPermit interface {
	Finish(completion APIBreakerCompletion)
}

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

type APIBreakerSettingsReader interface {
	Settings() settings.AgentSettings
}

type APIBreakerSnapshot struct {
	APIUpstreamID uint    `json:"api_upstream_id"`
	State         string  `json:"state"`
	RemainingMs   int64   `json:"remaining_ms"`
	Failures      int     `json:"failures"`
	Successes     int     `json:"successes"`
	FailureRate   float64 `json:"failure_rate"`
}

type APIClientAbortReason string

type APIExecution struct {
	Request           *RequestContext
	Result            apiattempt.APIExecutionResult
	Err               error
	StatusCode        int
	DurationMs        int
	QuotaGateDecision string
	SourceAgentID     string
}

type APILimiterFinder interface {
	EffectiveSourceAPILimiters(userID, groupID, serviceID, routeID uint) []cache.APILimiter
	EffectiveUpstreamAPILimiters(upstreamID uint) []cache.APILimiter
}

type APIMetrics struct {
	Requests     *prometheus.CounterVec
	Dispatches   *prometheus.CounterVec
	Active       *prometheus.GaugeVec
	UsageDropped prometheus.Counter
	TraceSlimmed prometheus.Counter
}

type APIPermit interface {
	Release()
}

type APIRequestFacts struct {
	UserID, GroupID, TokenID uint
	APIServiceID, APIRouteID uint
	APIUpstreamID            uint
	RequestID                string
	NoWait                   bool
}

type APIRoleSetFinder interface {
	FindUserAPIRoleSet(context.Context, uint) (*protocol.APIRoleSet, bool, error)
	FindTokenAPIRoleSet(context.Context, uint) (*protocol.APIRoleSet, bool, error)
}

type APIServiceRouteByIDFinder interface {
	FindServiceRouteByID(serviceID, routeID uint) (ServiceRoute, error)
}

type APIStatusFailurePredicate func(status int) bool

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

type APITraceSettingsReader interface {
	Settings() settings.AgentSettings
}

type APIUpstreamIndex interface {
	UpstreamsForBackend(backendID uint) []protocol.SyncedAPIUpstream
}

type APIUpstreamLease struct {
	Upstream protocol.SyncedAPIUpstream
	// contains filtered or unexported fields
}

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

type APIUsageBuilder interface {
	Build(APIExecution) protocol.APIUsageEntry
}

type APIUsageReporter interface {
	EnqueueAPI(protocol.APIUsageEntry) error
}

type AgentPick struct {
	ExecutionAgentID string
	AgentRouteID     uint
	AgentRoutePath   app.RoutePath
	Target           models.Agent
}

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

type ExecutionAgentCapabilityFinder interface {
	SupportsGenericAPIExecution(agentID string) bool
}

type ExecutionAgentPicker interface {
	Pick(tokenID, routeID, serviceID uint, requestID string) (AgentPick, error)
}

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

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

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

type GenericAPIUsageSupport interface {
	SupportsGenericAPIUsage() bool
}

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

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

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

type HTTPUpstreamPicker interface {
	Pick(uint, apiattempt.APIProtocol, string) (*APIUpstreamLease, error)
}

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

type HandlerOptions struct {
	Finder                ServiceRouteFinder
	Permission            PermissionChecker
	Quota                 QuotaChecker
	Limiter               SourceLimiter
	AgentPicker           ExecutionAgentPicker
	ExecutionCapabilities ExecutionAgentCapabilityFinder
	Usage                 APIUsageBuilder
	Reporter              APIUsageReporter
	MasterUsageSupport    GenericAPIUsageSupport
	SourceAgentID         string
	TraceSettings         APITraceSettingsReader
	Metrics               *APIMetrics
	Logger                *zap.Logger
	Executor              RequestExecutor
	// Handlers is retained for test and embedding compatibility. New production
	// assembly should inject Executor explicitly.
	Handlers map[string]ProtocolHandler
}

type HeaderBuilder struct{}

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

type PermissionChecker interface {
	AllowInvoke(context.Context, uint, uint, uint, uint) error
}

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

type ProtocolHandler interface {
	Serve(context.Context, *RequestContext) error
}

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

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

type PublisherOptions struct {
	Usage         APIUsageBuilder
	Reporter      APIUsageReporter
	SourceAgentID string
	Metrics       *APIMetrics
	Logger        *zap.Logger
}

type QuotaChecker interface {
	Allow(context.Context, uint, protocol.SyncedAPIService) error
}

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

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

type RemoteHTTPHandlerOptions struct {
	Direct       agentproxy.DirectHTTPAPITransportBuilder
	Relay        app.HTTPAPIStreamOpener
	GlobalProxy  string
	AddressTag   string
	PreferredTag string
}

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

type RemoteWebSocketHandlerOptions struct {
	Direct         agentproxy.DirectWebSocketAPIStreamOpener
	Relay          app.WebSocketAPIStreamOpener
	TargetSupports func(string) bool
	GlobalProxy    string
	AddressTag     string
	PreferredTag   string
	Settings       SettingsFinder
}

type RequestBuilder struct{}

type RequestBuilderInput struct {
	Request  *http.Request
	Route    protocol.SyncedAPIRoute
	Upstream protocol.SyncedAPIUpstream
	Subpath  string
	RawQuery string
}

type RequestContext struct {
	Context                *gin.Context
	Service                protocol.SyncedAPIService
	Route                  protocol.SyncedAPIRoute
	Protocol               string
	Subpath                string
	TokenID                uint
	TokenName              string
	UserID                 uint
	RequestID              string
	GroupID                uint
	Agent                  AgentPick
	Execution              apiattempt.APIExecutionResult
	UpstreamName           string
	QuotaGateDecision      string
	TracePolicy            apiattempt.APITracePolicy
	ClientUpgradeCommitted bool
	ClientStatusCode       int
	// contains filtered or unexported fields
}

type RequestExecutor interface {
	Execute(context.Context, *RequestContext) error
}

type RequestHash func(requestID string) uint64

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

type ServiceRoute struct {
	Service  protocol.SyncedAPIService
	Route    protocol.SyncedAPIRoute
	Protocol string
}

type ServiceRouteFinder interface {
	Find(serviceSlug, requestPath, method, requestedProtocol string) (ServiceRoute, string, error)
}

type SettingsFinder interface {
	Settings() settings.AgentSettings
}

type SourceLimiter interface {
	Acquire(context.Context, APIRequestFacts) (APIPermit, error)
}

type TokenFactFinder interface {
	FindTokenByID(context.Context, uint) (*models.Token, bool, error)
}

type UpstreamURLBuilder struct{}

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

type UserFactFinder interface {
	FindUser(context.Context, uint) (*protocol.SyncedUser, bool, error)
}

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

type WebSocketBridgeResult struct{ CloseCode int }

type WebSocketDialer interface {
	DialContext(context.Context, string, http.Header) (*websocket.Conn, *http.Response, error)
}

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

type WebSocketHandlerOptions struct {
	Picker   WebSocketUpstreamPicker
	Dialer   WebSocketDialer
	Limiter  SourceLimiter
	Settings SettingsFinder
}

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

type WebSocketTargetHandlerOptions struct {
	Finder   APIServiceRouteByIDFinder
	Picker   WebSocketUpstreamPicker
	Dialer   WebSocketDialer
	Limiter  SourceLimiter
	Settings SettingsFinder
}

type WebSocketUpstreamPicker interface {
	Pick(uint, apiattempt.APIProtocol, string) (*APIUpstreamLease, error)
}