fiber

type ActionHandler func(client *WSClient, payload interface{})

type AppError struct {
	Code       ErrorCode              `json:"code"`
	Message    string                 `json:"message"`
	Details    map[string]interface{} `json:"details,omitempty"`
	Stack      string                 `json:"stack,omitempty"`
	StatusCode int                    `json:"-"`
	Recover    bool                   `json:"-"` // Whether state can be recovered
}

type AtomicRateLimiterStorage interface {
	ConsumeRateLimitToken(ctx context.Context, key string, now time.Time, maxTokens float64, refillRate float64, ttl time.Duration) (bool, error)
}

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

type CompressedContent struct {
	Original []byte
	Brotli   []byte
	Gzip     []byte
}

type CompressionConfig struct {
	// EnableBrotli enables Brotli compression (better compression ratio)
	EnableBrotli bool
	// EnableGzip enables Gzip compression (wider browser support)
	EnableGzip bool
	// BrotliLevel compression level (0-11, default 4 for balance)
	BrotliLevel int
	// GzipLevel compression level (1-9, default 6 for balance)
	GzipLevel int
	// MinSize minimum response size to compress (default 1024 bytes)
	MinSize int
	// CompressibleTypes content types that should be compressed
	CompressibleTypes []string
	// SkipCompression paths to skip compression for
	SkipPaths []string
	// MaxBufferedSize caps the size of responses this middleware will buffer
	// and compress in-memory. Larger responses are left untouched so callers
	// can use streaming or upstream compression instead.
	MaxBufferedSize int
}

type Config struct {
	// RuntimeScript is the path to the client runtime script
	RuntimeScript string
	// EnableWebSocket indicates websocket support is expected by the page bootstrap.
	EnableWebSocket bool
	// WebSocketPath is the websocket endpoint path.
	WebSocketPath string
	// ExpectCSPNonce enables startup diagnostics for nonce-based CSP setups.
	ExpectCSPNonce bool
	// StartupChecks injects runtime self-check diagnostics.
	StartupChecks bool
	// StateKey is the context key for storing state
	StateKey string
	// ComponentIDKey is the context key for component IDs
	ComponentIDKey string
	// DevMode enables development features
	DevMode bool
	// DefaultState is the initial state for new sessions
	DefaultState map[string]interface{}
	// Logger is the structured logger. Defaults to slog.Default().
	Logger *slog.Logger
	// BuildManifest is the loaded manifest.json (optional)
	BuildManifest map[string]string
}

type ConnectHandler func(client *WSClient)

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

type DevConfig struct {
	// Enabled enables development mode
	Enabled bool
	// RoutesDir is the directory containing route files
	RoutesDir string
	// ComponentsDir is the directory containing component files
	ComponentsDir string
	// WatchPaths are additional paths to watch for changes
	WatchPaths []string
	// IgnorePaths are paths to ignore
	IgnorePaths []string
	// Debounce is the debounce time for file changes
	Debounce time.Duration
	// OnReload is called when files change
	OnReload func()
	// StateKey is the context key for state
	StateKey string
	// AllowInsecureWS allows unsecure ws:// connections
	AllowInsecureWS bool
	// HMRManager is an optional HMR manager to use for file watching instead of polling
	// When set, DevTools will subscribe to HMR file change events instead of using
	// the legacy polling FileWatcher. This reduces CPU usage significantly.
	HMRManager *HMRManager
}

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

type ErrorCode string

type ErrorHandlerConfig struct {
	// DevMode enables development features like stack traces
	DevMode bool
	// StateKey is the context key for state
	StateKey string
	// CustomErrorPages maps error codes to custom handlers
	CustomErrorPages map[ErrorCode]func(fiberpkg.Ctx, *AppError) error
	// OnError is called when an error occurs
	OnError func(fiberpkg.Ctx, *AppError)
	// RecoverState attempts to recover state on error
	RecoverState bool
}

type ErrorInfo struct {
	Message     string       `json:"message"`
	Type        string       `json:"type"`
	Stack       []StackFrame `json:"stack"`
	File        string       `json:"file"`
	Line        int          `json:"line"`
	Column      int          `json:"column"`
	CodeSnippet string       `json:"codeSnippet"`
	Timestamp   int64        `json:"timestamp"`
	Request     *RequestInfo `json:"request,omitempty"`
	Cause       *ErrorInfo   `json:"cause,omitempty"`
}

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

type ErrorOverlayConfig struct {
	Enabled     bool
	ShowStack   bool
	ShowRequest bool
	ShowCode    bool
	Theme       string // "dark" or "light"
	Editor      string // editor to open files in (e.g., "code", "idea")
	EditorPort  int
}

type HMRConfig struct {
	Enabled         bool          `json:"enabled"`
	WatchPaths      []string      `json:"watchPaths"`
	IgnorePaths     []string      `json:"ignorePaths"`
	DebounceTime    time.Duration `json:"debounceTime"`
	AllowInsecureWS bool          `json:"allowInsecureWS"`
}

type HMRFileChangeEvent struct {
	Path      string    `json:"path"`
	EventType string    `json:"eventType"` // "create", "modify", "delete"
	Timestamp time.Time `json:"timestamp"`
}

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

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

type HMRMessage struct {
	Type         string `json:"type"` // "update", "reload", "error", "state-preserve", "connected"
	Path         string `json:"path,omitempty"`
	ModuleID     string `json:"moduleId,omitempty"`
	Event        string `json:"event,omitempty"`
	ReloadReason string `json:"reloadReason,omitempty"` // "template-safe" | "style-safe" | "runtime-break" | "config-break"
	State        any    `json:"state,omitempty"`
	Error        string `json:"error,omitempty"`
	Timestamp    int64  `json:"timestamp"`
}

type HMRUpdatePayload struct {
	ModuleID      string `json:"moduleId"`
	Path          string `json:"path"`
	UpdateType    string `json:"updateType"` // "template", "script", "style", "full"
	Content       string `json:"content,omitempty"`
	StatePreserve bool   `json:"statePreserve"`
}

type PreloadConfig struct {
	RuntimeScript    string
	NavigationScript string
	WebSocketScript  string
	CoreScript       string
	MicroScript      string
	// CSSLinks contains stylesheets to preload with high priority
	CSSLinks []string
	Enabled  bool
	// BuildManifest is the loaded manifest.json (optional)
	BuildManifest map[string]string
}

type RequestInfo struct {
	Method  string            `json:"method"`
	URL     string            `json:"url"`
	Headers map[string]string `json:"headers,omitempty"`
	Query   map[string]string `json:"query,omitempty"`
}

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

type SSEClient struct {
	// ID is the unique client identifier
	ID string
	// Channel is the client's event channel
	Channel chan SSEEvent
	// ConnectedAt is the connection timestamp
	ConnectedAt time.Time
	// Metadata contains additional client data
	Metadata map[string]any
	// Topics the client is subscribed to
	Topics map[string]bool
}

type SSEConfig struct {
	// EventBufferSize is the buffer size for client channels
	EventBufferSize int
	// HeartbeatInterval is the keepalive interval (0 to disable)
	HeartbeatInterval time.Duration
	// OnConnect is called when a client connects
	OnConnect func(*SSEClient)
	// OnDisconnect is called when a client disconnects
	OnDisconnect func(*SSEClient)
	// PubSub backend for distributed environments
	PubSub store.PubSub
	// AuthorizeSubscribe is called to authorize a subscription request.
	// It should return true if the requester (c) is authorized to subscribe the client (clientID).
	AuthorizeSubscribe func(c fiberpkg.Ctx, clientID string) bool
}

type SSEEvent struct {
	// ID is the event identifier
	ID string `json:"id,omitempty"`
	// Event is the event type/name
	Event string `json:"event,omitempty"`
	// Data is the event payload
	Data any `json:"data"`
	// Retry specifies reconnection time in milliseconds
	Retry int `json:"retry,omitempty"`
}

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

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

type StackFrame struct {
	File     string `json:"file"`
	Line     int    `json:"line"`
	Function string `json:"function"`
	Source   string `json:"source,omitempty"`
}

type StateLogEntry struct {
	Timestamp time.Time   `json:"timestamp"`
	Key       string      `json:"key"`
	OldValue  interface{} `json:"oldValue,omitempty"`
	NewValue  interface{} `json:"newValue"`
	Source    string      `json:"source"` // "client" or "server"
}

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

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

type WSClient struct {
	ID        string
	SessionID string
	Conn      *websocket.Conn
	Send      chan []byte
	State     *state.StateMap
	// contains filtered or unexported fields
}

type WSHub struct {
	Clients          map[string]*WSClient
	ClientsBySession map[string]map[string]*WSClient // SessionID -> {ClientID -> *WSClient}
	ClientsByTopic   map[string]map[string]*WSClient // Topic -> {ClientID -> *WSClient}
	Register         chan *WSClient
	Unregister       chan *WSClient
	Broadcast        chan []byte
	// contains filtered or unexported fields
}

type WSMessage struct {
	Type         string                 `json:"type" msgpack:"type"`
	ComponentID  string                 `json:"componentId,omitempty" msgpack:"componentId,omitempty"`
	Action       string                 `json:"action,omitempty" msgpack:"action,omitempty"`
	Data         map[string]interface{} `json:"data,omitempty" msgpack:"data,omitempty"`
	Payload      interface{}            `json:"payload,omitempty" msgpack:"payload,omitempty"`
	SessionToken string                 `json:"sessionToken,omitempty" msgpack:"sessionToken,omitempty"`
	ClientID     string                 `json:"clientId,omitempty" msgpack:"clientId,omitempty"`
}

type WSStateUpdate struct {
	Key   string      `json:"key" msgpack:"key"`
	Value interface{} `json:"value" msgpack:"value"`
}

type WebSocketConfig struct {
	// Hub is the WebSocket hub for managing connections.
	Hub *WSHub
	// OnConnect is called when a client connects.
	OnConnect func(*WSClient)
	// OnDisconnect is called when a client disconnects.
	OnDisconnect func(*WSClient)
	// OnMessage is called when a message is received.
	OnMessage func(*WSClient, WSMessage)
	// GenerateID generates a client ID.
	GenerateID func() string
	// CompressState enables gzip compression of outbound state payloads.
	// The client receives { type:'compressed', data: '<base64>', compressed:true }
	// and must decompress using the DecompressionStream browser API.
	CompressState bool
	// StateDiffing enables delta-only 'patch' messages instead of full state syncs.
	// When enabled only changed keys are broadcast after the initial snapshot.
	StateDiffing bool
	// Serializer overrides JSON for outbound state serialization.
	Serializer func(interface{}) ([]byte, error)
	// Deserializer overrides JSON for inbound state deserialization.
	Deserializer func([]byte, interface{}) error
	// SerializationFormat sets the underlying format for all WebSocket communications.
	SerializationFormat string
	// WSMaxMessageSize limits the maximum payload size for WebSocket messages.
	WSMaxMessageSize int
}