@djangocfg/centrifugo 2.1.102 → 2.1.104

package/dist/index.d.ts

@@ -1,838 +0,0 @@
-import { Centrifuge } from 'centrifuge';
-export * from 'centrifuge';
-import * as consola from 'consola';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-
-/**
- * Core Types for Centrifugo Package
- *
- * Type-only exports, no runtime dependencies
- */
-type LogLevel = 'debug' | 'info' | 'success' | 'warning' | 'error';
-interface LogEntry {
-    id: string;
-    timestamp: Date;
-    level: LogLevel;
-    source: 'client' | 'provider' | 'subscription' | 'system';
-    message: string;
-    data?: unknown;
-}
-type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'error';
-interface CentrifugoToken {
-    token: string;
-    centrifugo_url?: string;
-    channels: string[];
-    expires_at: string;
-}
-interface User {
-    id: number;
-    centrifugo?: CentrifugoToken;
-}
-interface ActiveSubscription {
-    channel: string;
-    type: 'client' | 'server';
-    subscribedAt: number;
-    data?: unknown;
-}
-interface CentrifugoClientConfig {
-    url: string;
-    token: string;
-    userId: string;
-    timeout?: number;
-    onLog?: (entry: Omit<LogEntry, 'id' | 'timestamp'>) => void;
-}
-interface CentrifugoClientState {
-    isConnected: boolean;
-    isConnecting: boolean;
-    error: Error | null;
-    connectionState: ConnectionState;
-}
-
-/**
- * Create Logger
- *
- * Creates logger that writes to both console (consola) and LogsStore.
- * Dual output: developer console + UI logs viewer.
- */
-
-interface Logger {
-    debug: (message: string, data?: unknown) => void;
-    info: (message: string, data?: unknown) => void;
-    success: (message: string, data?: unknown) => void;
-    warning: (message: string, data?: unknown) => void;
-    error: (message: string, error?: Error | unknown) => void;
-}
-interface LoggerConfig {
-    source: LogEntry['source'];
-    isDevelopment?: boolean;
-    tag?: string;
-}
-/**
- * Create a logger instance
- *
- * @param configOrPrefix - Either a full LoggerConfig object or a simple string prefix
- * @returns Logger instance
- *
- * @example
- * // Simple usage with prefix
- * const logger = createLogger('MyComponent');
- *
- * @example
- * // Advanced usage with full config
- * const logger = createLogger({
- *   source: 'client',
- *   tag: 'MyComponent',
- *   isDevelopment: true
- * });
- */
-declare function createLogger(configOrPrefix: LoggerConfig | string): Logger;
-
-/**
- * Logs Store
- *
- * In-memory store for accumulated logs with circular buffer.
- * Thread-safe, max capacity, auto-cleanup.
- */
-
-declare class LogsStore {
-    private logs;
-    private listeners;
-    private maxLogs;
-    constructor(maxLogs?: number);
-    /**
-     * Add log entry
-     */
-    add(entry: Omit<LogEntry, 'id' | 'timestamp'>): void;
-    /**
-     * Get all logs
-     */
-    getAll(): LogEntry[];
-    /**
-     * Get logs by level
-     */
-    getByLevel(level: LogLevel): LogEntry[];
-    /**
-     * Get logs by source
-     */
-    getBySource(source: LogEntry['source']): LogEntry[];
-    /**
-     * Clear all logs
-     */
-    clear(): void;
-    /**
-     * Subscribe to log changes
-     */
-    subscribe(listener: (logs: LogEntry[]) => void): () => void;
-    /**
-     * Notify all listeners
-     */
-    private notify;
-    /**
-     * Get logs count
-     */
-    get count(): number;
-}
-declare function getGlobalLogsStore(): LogsStore;
-
-/**
- * Centrifugo Client Types
- */
-
-interface CentrifugoClientOptions {
-    url: string;
-    token: string;
-    userId: string;
-    timeout?: number;
-    logger?: Logger;
-    /**
-     * Callback to get fresh token when current token expires.
-     * Centrifuge-js calls this automatically on token expiration.
-     */
-    getToken?: () => Promise<string>;
-}
-interface RPCOptions {
-    timeout?: number;
-    replyChannel?: string;
-}
-interface RetryOptions {
-    /** Max retry attempts (default: 3) */
-    maxRetries?: number;
-    /** Base delay in ms for exponential backoff (default: 100) */
-    baseDelayMs?: number;
-    /** Max delay cap in ms (default: 2000) */
-    maxDelayMs?: number;
-}
-interface VersionCheckResult {
-    compatible: boolean;
-    clientVersion: string;
-    serverVersion: string;
-    message: string;
-}
-
-/**
- * RPC Error with classification for retry logic.
- *
- * Mirrors Swift's RPCError implementation with:
- * - isRetryable: Whether the error should trigger a retry
- * - suggestedRetryDelay: Recommended delay before retry
- * - userMessage: User-friendly error message
- */
-type RPCErrorCode = 'not_connected' | 'timeout' | 'server_error' | 'encoding_error' | 'decoding_error' | 'websocket_error' | 'connection_failed' | 'cancelled' | 'network_error' | 'unknown';
-declare class RPCError extends Error {
-    readonly code: RPCErrorCode;
-    readonly serverCode?: number;
-    readonly method?: string;
-    readonly isRetryable: boolean;
-    readonly suggestedRetryDelay: number;
-    readonly userMessage: string;
-    constructor(code: RPCErrorCode, message: string, options?: {
-        serverCode?: number;
-        method?: string;
-        cause?: unknown;
-    });
-    /**
-     * Determine if this error should trigger a retry.
-     * Transient errors (timeout, network) are retryable.
-     * Permanent errors (encoding, 4xx) are not.
-     */
-    private determineRetryable;
-    /**
-     * Suggested delay before retry based on error type.
-     */
-    private determineSuggestedDelay;
-    /**
-     * User-friendly message for UI display.
-     */
-    private determineUserMessage;
-    /**
-     * Create RPCError from Centrifugo/unknown error.
-     */
-    static fromError(error: unknown, method?: string): RPCError;
-}
-
-/**
- * RPC Module
- *
- * Handles Centrifugo RPC patterns (request-response and fire-and-forget).
- */
-
-interface NamedRPCWithRetryOptions {
-    timeout?: number;
-    maxRetries?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    onRetry?: (attempt: number, error: RPCError, delayMs: number) => void;
-}
-
-/**
- * Centrifugo RPC Client
- *
- * Facade for WebSocket connection and RPC call handling.
- * Provides both RPC (request/response) and Subscription (pub/sub) patterns.
- *
- * Architecture:
- * - connection.ts  - Connection lifecycle management
- * - subscriptions.ts - Channel subscription management
- * - rpc.ts - RPC methods (namedRPC, namedRPCNoWait)
- * - version.ts - API version checking
- * - types.ts - Type definitions
- */
-
-declare class CentrifugoRPCClient {
-    private state;
-    constructor(options: CentrifugoClientOptions);
-    /** @deprecated Use options object instead */
-    constructor(url: string, token: string, userId: string, timeout?: number, logger?: Logger);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    getCentrifuge(): Centrifuge;
-    subscribe(channel: string, callback: (data: any) => void): () => void;
-    unsubscribe(channel: string): void;
-    unsubscribeAll(): void;
-    getActiveSubscriptions(): string[];
-    getServerSideSubscriptions(): string[];
-    getAllSubscriptions(): string[];
-    call<T = any>(method: string, params: any): Promise<T>;
-    rpc<TRequest = any, TResponse = any>(method: string, params: TRequest, options?: RPCOptions): Promise<TResponse>;
-    namedRPC<TRequest = any, TResponse = any>(method: string, data: TRequest, options?: {
-        timeout?: number;
-    }): Promise<TResponse>;
-    namedRPCNoWait<TRequest = any>(method: string, data: TRequest, options?: RetryOptions): void;
-    namedRPCWithRetry<TRequest = any, TResponse = any>(method: string, data: TRequest, options?: NamedRPCWithRetryOptions): Promise<TResponse>;
-    checkApiVersion(clientVersion: string): Promise<VersionCheckResult>;
-    private handleResponse;
-    private get subscriptionManager();
-    private get rpcManager();
-    /** @internal */
-    get logger(): Logger;
-    /** @internal */
-    get userId(): string;
-    /** @internal */
-    get replyChannel(): string;
-}
-
-/**
- * Shared consola logger for Centrifugo package
- */
-declare const consolaLogger: consola.ConsolaInstance;
-/**
- * Get a consola logger with custom tag wrapped to match Logger interface
- */
-declare function getConsolaLogger(tag: string): Logger;
-
-interface CentrifugoContextValue {
-    client: CentrifugoRPCClient | null;
-    isConnected: boolean;
-    isConnecting: boolean;
-    error: Error | null;
-    connectionState: ConnectionState;
-    uptime: number;
-    subscriptions: string[];
-    activeSubscriptions: ActiveSubscription[];
-    connect: () => Promise<void>;
-    disconnect: () => void;
-    reconnect: () => Promise<void>;
-    unsubscribe: (channel: string) => void;
-    enabled: boolean;
-}
-interface CentrifugoProviderProps {
-    children: ReactNode;
-    enabled?: boolean;
-    url?: string;
-    autoConnect?: boolean;
-    /**
-     * Callback to refresh the Centrifugo token when it expires.
-     * If provided, centrifuge-js will automatically call this when token expires.
-     * Should return a fresh JWT token string.
-     *
-     * @example
-     * onTokenRefresh={async () => {
-     *   const response = await getCentrifugoAuthTokenRetrieve();
-     *   return response.token;
-     * }}
-     */
-    onTokenRefresh?: () => Promise<string>;
-}
-declare function CentrifugoProvider(props: CentrifugoProviderProps): react_jsx_runtime.JSX.Element;
-declare function useCentrifugo(): CentrifugoContextValue;
-
-interface LogsContextValue {
-    logs: LogEntry[];
-    filteredLogs: LogEntry[];
-    filter: LogsFilter;
-    setFilter: (filter: Partial<LogsFilter>) => void;
-    clearLogs: () => void;
-    count: number;
-}
-interface LogsFilter {
-    level?: LogLevel;
-    source?: LogEntry['source'];
-    search?: string;
-}
-interface LogsProviderProps {
-    children: ReactNode;
-}
-declare function LogsProvider({ children }: LogsProviderProps): react_jsx_runtime.JSX.Element;
-declare function useLogs(): LogsContextValue;
-
-/**
- * useSubscription Hook
- *
- * Subscribe to Centrifugo channel with auto-cleanup.
- *
- * Best practices:
- * - Callbacks are stored in refs to avoid re-subscriptions
- * - Proper error handling in callbacks (as recommended by centrifuge-js)
- * - Cleanup on unmount
- * - Stable unsubscribe function
- */
-interface UseSubscriptionOptions<T = any> {
-    channel: string;
-    enabled?: boolean;
-    onPublication?: (data: T) => void;
-    onError?: (error: Error) => void;
-}
-interface UseSubscriptionResult<T = any> {
-    data: T | null;
-    error: Error | null;
-    isSubscribed: boolean;
-    unsubscribe: () => void;
-}
-declare function useSubscription<T = any>(options: UseSubscriptionOptions<T>): UseSubscriptionResult<T>;
-
-/**
- * useRPC Hook
- *
- * React hook for making RPC calls via Centrifugo using correlation ID pattern.
- * Provides type-safe request-response communication over WebSocket.
- *
- * Pattern:
- * 1. Client sends request with correlation_id to rpc#{method}
- * 2. Backend processes and sends response to user#{userId} with same correlation_id
- * 3. Client matches response by correlation_id and resolves Promise
- *
- * @example
- * const { call, isLoading, error } = useRPC();
- *
- * const handleGetStats = async () => {
- *   const result = await call('tasks.get_stats', { bot_id: '123' });
- *   console.log('Stats:', result);
- * };
- */
-interface UseRPCOptions {
-    timeout?: number;
-    replyChannel?: string;
-    onError?: (error: Error) => void;
-}
-interface UseRPCResult {
-    call: <TRequest = any, TResponse = any>(method: string, params: TRequest, options?: UseRPCOptions) => Promise<TResponse>;
-    isLoading: boolean;
-    error: Error | null;
-    reset: () => void;
-}
-declare function useRPC(defaultOptions?: UseRPCOptions): UseRPCResult;
-
-/**
- * useNamedRPC Hook
- *
- * React hook for making native Centrifugo RPC calls via RPC proxy.
- * Uses Centrifugo's built-in RPC mechanism which proxies to Django.
- *
- * Flow:
- * 1. Client calls namedRPC('terminal.input', data)
- * 2. Centrifuge.js sends RPC over WebSocket
- * 3. Centrifugo proxies to Django: POST /centrifugo/rpc/
- * 4. Django routes to @websocket_rpc handler
- * 5. Response returned to client
- *
- * @example
- * const { call, isLoading, error } = useNamedRPC();
- *
- * const handleSendInput = async () => {
- *   const result = await call('terminal.input', {
- *     session_id: 'abc-123',
- *     data: btoa('ls -la')
- *   });
- *   console.log('Result:', result);
- * };
- */
-interface UseNamedRPCOptions {
-    onError?: (error: Error) => void;
-}
-interface UseNamedRPCResult {
-    call: <TRequest = any, TResponse = any>(method: string, data: TRequest) => Promise<TResponse>;
-    isLoading: boolean;
-    error: Error | null;
-    reset: () => void;
-}
-declare function useNamedRPC(defaultOptions?: UseNamedRPCOptions): UseNamedRPCResult;
-
-/**
- * usePageVisibility Hook
- *
- * Tracks browser tab visibility state using the Page Visibility API.
- * Returns true when the page is visible, false when hidden.
- *
- * Use cases:
- * - Pause/resume WebSocket connections
- * - Pause expensive operations when tab is inactive
- * - Trigger data sync when tab becomes visible
- */
-interface PageVisibilityState {
-    /** Whether the page is currently visible */
-    isVisible: boolean;
-    /** Whether the page was ever hidden during this session */
-    wasHidden: boolean;
-    /** Timestamp when page became visible (for uptime tracking) */
-    visibleSince: number | null;
-    /** How long the page was hidden (ms), reset when visible */
-    hiddenDuration: number;
-}
-interface UsePageVisibilityOptions {
-    /** Callback when page becomes visible */
-    onVisible?: () => void;
-    /** Callback when page becomes hidden */
-    onHidden?: () => void;
-    /** Callback with visibility state change */
-    onChange?: (isVisible: boolean) => void;
-}
-interface UsePageVisibilityResult extends PageVisibilityState {
-    /** Force check visibility state */
-    checkVisibility: () => boolean;
-}
-declare function usePageVisibility(options?: UsePageVisibilityOptions): UsePageVisibilityResult;
-
-/**
- * useCodegenTip Hook
- *
- * Shows development tip about client generation once per session.
- */
-/**
- * Show dev tip about generating type-safe clients from @websocket_rpc handlers
- *
- * @example
- * function MyComponent() {
- *   useCodegenTip();
- *   // ... rest of component
- * }
- */
-declare function useCodegenTip(): void;
-
-/**
- * Centrifugo Package Configuration
- */
-declare const isDevelopment: boolean;
-declare const isProduction: boolean;
-declare const isStaticBuild: boolean;
-declare const centrifugoConfig: {
-    readonly showDebugPanel: boolean;
-    readonly reconnect: {
-        readonly initialDelay: 1000 | 2000;
-        readonly maxDelay: 30000 | 60000;
-        readonly multiplier: 1.5;
-        readonly maxAttempts: 3 | 10;
-        readonly jitter: 0.1;
-    };
-};
-type CentrifugoConfig = typeof centrifugoConfig;
-
-/**
- * RPC Retry Handler with exponential backoff.
- *
- * Mirrors Swift's RPCRetryHandler implementation with:
- * - Configurable max retries and delays
- * - Exponential backoff with jitter
- * - Retry decision based on RPCError.isRetryable
- */
-
-interface RetryConfig {
-    maxRetries: number;
-    baseDelayMs: number;
-    maxDelayMs: number;
-    jitterFactor: number;
-}
-declare const DEFAULT_RETRY_CONFIG: RetryConfig;
-interface RetryState {
-    attempt: number;
-    lastError: RPCError | null;
-    totalDelayMs: number;
-}
-/**
- * Calculate delay with exponential backoff and jitter.
- */
-declare function calculateDelay(attempt: number, config: RetryConfig, error?: RPCError): number;
-/**
- * Sleep for specified milliseconds.
- */
-declare function sleep(ms: number): Promise<void>;
-/**
- * Execute operation with retry logic.
- *
- * @param operation - Async function to execute
- * @param config - Retry configuration
- * @param onRetry - Optional callback before each retry
- * @returns Promise with operation result
- * @throws RPCError after all retries exhausted
- */
-declare function withRetry<T>(operation: () => Promise<T>, config?: Partial<RetryConfig>, onRetry?: (state: RetryState, delayMs: number) => void): Promise<T>;
-/**
- * Create a retry wrapper for RPC calls.
- */
-declare function createRetryHandler(config?: Partial<RetryConfig>): {
-    config: RetryConfig;
-    /**
-     * Execute with retry.
-     */
-    execute: <T>(operation: () => Promise<T>, onRetry?: (state: RetryState, delayMs: number) => void) => Promise<T>;
-    /**
-     * Check if error should be retried.
-     */
-    shouldRetry: (error: unknown, attempt: number) => boolean;
-    /**
-     * Get delay for next retry.
-     */
-    getDelay: (attempt: number, error?: unknown) => number;
-};
-
-/**
- * Centrifugo Package Events
- *
- * Unified event system for Centrifugo client.
- * All events use single 'centrifugo' CustomEvent with type discriminator.
- */
-/**
- * Single event name for all Centrifugo events.
- * Use `type` field in payload to distinguish event types.
- */
-declare const CENTRIFUGO_EVENT: "centrifugo";
-/**
- * Internal events for UI components (via events.publish)
- */
-declare const CENTRIFUGO_MONITOR_EVENTS: {
-    readonly OPEN_MONITOR_DIALOG: "CENTRIFUGO_OPEN_MONITOR_DIALOG";
-    readonly CLOSE_MONITOR_DIALOG: "CENTRIFUGO_CLOSE_MONITOR_DIALOG";
-};
-declare const CENTRIFUGO_ERROR_EVENT: "centrifugo";
-declare const CENTRIFUGO_VERSION_MISMATCH_EVENT: "centrifugo";
-type CentrifugoEventType = 'error' | 'version_mismatch' | 'connected' | 'disconnected' | 'reconnecting';
-interface CentrifugoErrorData {
-    /** RPC method that failed */
-    method: string;
-    /** Error message */
-    error: string;
-    /** Error code from Centrifugo */
-    code?: number;
-    /** Additional data sent with the request */
-    data?: any;
-}
-interface CentrifugoVersionMismatchData {
-    /** Client API version hash */
-    clientVersion: string;
-    /** Server API version hash */
-    serverVersion: string;
-    /** Human-readable message */
-    message: string;
-}
-interface CentrifugoConnectionData {
-    /** User ID */
-    userId?: string;
-    /** Reconnect attempt number (for reconnecting) */
-    attempt?: number;
-    /** Reason for disconnect */
-    reason?: string;
-}
-/**
- * Unified Centrifugo event payload
- */
-type CentrifugoEventPayload = {
-    type: 'error';
-    data: CentrifugoErrorData;
-} | {
-    type: 'version_mismatch';
-    data: CentrifugoVersionMismatchData;
-} | {
-    type: 'connected';
-    data: CentrifugoConnectionData;
-} | {
-    type: 'disconnected';
-    data: CentrifugoConnectionData;
-} | {
-    type: 'reconnecting';
-    data: CentrifugoConnectionData;
-};
-/**
- * Full event detail (includes timestamp)
- */
-type CentrifugoEventDetail = CentrifugoEventPayload & {
-    timestamp: Date;
-};
-interface OpenMonitorDialogPayload {
-    variant?: 'compact' | 'full' | 'minimal';
-    defaultTab?: 'connection' | 'messages' | 'subscriptions';
-}
-/** @deprecated Use CentrifugoErrorData */
-type CentrifugoErrorPayload = CentrifugoErrorData;
-/** @deprecated Use CentrifugoVersionMismatchData */
-type VersionMismatchPayload = CentrifugoVersionMismatchData;
-/**
- * Dispatch unified Centrifugo event
- *
- * @example
- * ```ts
- * // Dispatch error
- * dispatchCentrifugoEvent({
- *   type: 'error',
- *   data: { method: 'terminal.input', error: 'timeout' }
- * });
- *
- * // Listen to all Centrifugo events
- * window.addEventListener('centrifugo', (e) => {
- *   const { type, data, timestamp } = e.detail;
- *   switch (type) {
- *     case 'error':
- *       console.error('RPC error:', data.method, data.error);
- *       break;
- *     case 'version_mismatch':
- *       toast.warning('Please refresh the page');
- *       break;
- *   }
- * });
- * ```
- */
-declare const dispatchCentrifugoEvent: (payload: CentrifugoEventPayload) => void;
-/**
- * Dispatch error event
- */
-declare const dispatchCentrifugoError: (data: CentrifugoErrorData) => void;
-/**
- * Dispatch version mismatch event
- */
-declare const dispatchVersionMismatch: (data: CentrifugoVersionMismatchData) => void;
-/**
- * Dispatch connected event
- */
-declare const dispatchConnected: (data?: CentrifugoConnectionData) => void;
-/**
- * Dispatch disconnected event
- */
-declare const dispatchDisconnected: (data?: CentrifugoConnectionData) => void;
-/**
- * Dispatch reconnecting event
- */
-declare const dispatchReconnecting: (data?: CentrifugoConnectionData) => void;
-declare const emitOpenMonitorDialog: (payload?: OpenMonitorDialogPayload) => void;
-declare const emitCloseMonitorDialog: () => void;
-
-/**
- * Connection Status Component
- *
- * Universal component for displaying Centrifugo connection status
- * Supports multiple variants: badge, inline, card, detailed
- */
-interface ConnectionStatusProps {
-    variant?: 'badge' | 'inline' | 'detailed';
-    showUptime?: boolean;
-    showSubscriptions?: boolean;
-    className?: string;
-}
-declare function ConnectionStatus({ variant, showUptime, showSubscriptions, className, }: ConnectionStatusProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Connection Status Card Component
- *
- * Card wrapper for ConnectionStatus - ready for dashboard widgets
- * Clickable - opens CentrifugoMonitorDialog on click via events
- */
-interface ConnectionStatusCardProps {
-    showUptime?: boolean;
-    showSubscriptions?: boolean;
-    className?: string;
-}
-declare function ConnectionStatusCard({ showUptime, showSubscriptions, className, }: ConnectionStatusCardProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Messages Feed Types
- */
-interface CentrifugoMessage {
-    id: string;
-    timestamp: number;
-    type: 'connection' | 'subscription' | 'publication' | 'error' | 'system' | 'unsubscription';
-    channel?: string;
-    data?: any;
-    level: 'info' | 'success' | 'warning' | 'error';
-    message?: string;
-}
-interface MessageFilters$1 {
-    channels?: string[];
-    types?: CentrifugoMessage['type'][];
-    levels?: CentrifugoMessage['level'][];
-    searchQuery?: string;
-}
-interface MessagesFeedProps {
-    maxMessages?: number;
-    showFilters?: boolean;
-    showControls?: boolean;
-    channels?: string[];
-    autoScroll?: boolean;
-    onMessageClick?: (message: CentrifugoMessage) => void;
-    className?: string;
-}
-
-declare function MessagesFeed({ maxMessages, showFilters, showControls, channels, autoScroll: initialAutoScroll, onMessageClick, className, }: MessagesFeedProps): react_jsx_runtime.JSX.Element;
-
-interface MessageFiltersProps {
-    filters: MessageFilters$1;
-    onFiltersChange: (filters: MessageFilters$1) => void;
-    autoScroll?: boolean;
-    onAutoScrollChange?: (enabled: boolean) => void;
-}
-declare function MessageFilters({ filters, onFiltersChange, autoScroll, onAutoScrollChange, }: MessageFiltersProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Subscriptions List Component
- *
- * Displays active Centrifugo subscriptions with status and controls
- */
-interface SubscriptionsListProps {
-    showControls?: boolean;
-    onSubscriptionClick?: (channel: string) => void;
-    className?: string;
-}
-declare function SubscriptionsList({ showControls, onSubscriptionClick, className, }: SubscriptionsListProps): react_jsx_runtime.JSX.Element;
-
-interface CentrifugoMonitorProps {
-    variant?: 'compact' | 'full' | 'minimal';
-    showConnectionStatus?: boolean;
-    showMessagesFeed?: boolean;
-    showSubscriptions?: boolean;
-    showFilters?: boolean;
-    showControls?: boolean;
-    maxMessages?: number;
-    channels?: string[];
-    autoScroll?: boolean;
-    onMessageClick?: (message: CentrifugoMessage) => void;
-    onSubscriptionClick?: (channel: string) => void;
-    className?: string;
-}
-declare function CentrifugoMonitor({ variant, showConnectionStatus, showMessagesFeed, showSubscriptions, showFilters, showControls, maxMessages, channels, autoScroll, onMessageClick, onSubscriptionClick, className, }: CentrifugoMonitorProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Centrifugo Monitor Dialog Component
- *
- * Sheet/Dialog wrapper for CentrifugoMonitor
- * Uses event-driven approach - listens to OPEN_MONITOR_DIALOG event
- */
-declare function CentrifugoMonitorDialog(): react_jsx_runtime.JSX.Element;
-
-interface CentrifugoMonitorFABProps {
-    position?: 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right';
-    size?: 'sm' | 'md' | 'lg';
-    variant?: OpenMonitorDialogPayload['variant'];
-}
-declare function CentrifugoMonitorFAB({ position, size, variant, }: CentrifugoMonitorFABProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Centrifugo Monitor Widget Component
- *
- * Card-based widget for dashboards
- * Opens monitor dialog via events
- */
-interface CentrifugoMonitorWidgetProps {
-    title?: string;
-    showExpandButton?: boolean;
-    className?: string;
-}
-declare function CentrifugoMonitorWidget({ title, showExpandButton, className, }: CentrifugoMonitorWidgetProps): react_jsx_runtime.JSX.Element;
-
-/**
- * Debug Panel
- *
- * Main debug UI with FAB button + Sheet modal + Tabs.
- * Visibility controlled by CentrifugoProvider (dev mode OR admin users).
- */
-declare function DebugPanel(): react_jsx_runtime.JSX.Element;
-
-/**
- * Connection Tab
- *
- * Shows WebSocket connection status, uptime, and controls.
- */
-declare function ConnectionTab(): react_jsx_runtime.JSX.Element;
-
-/**
- * Logs Tab
- *
- * Bash-like logs viewer with filters, search, and auto-scroll.
- * Uses PrettyCode for syntax highlighting.
- */
-declare function LogsTab(): react_jsx_runtime.JSX.Element;
-
-/**
- * Subscriptions Tab
- *
- * Shows active channel subscriptions with controls.
- */
-declare function SubscriptionsTab(): react_jsx_runtime.JSX.Element;
-
-export { type ActiveSubscription, CENTRIFUGO_ERROR_EVENT, CENTRIFUGO_EVENT, CENTRIFUGO_MONITOR_EVENTS, CENTRIFUGO_VERSION_MISMATCH_EVENT, type CentrifugoClientConfig, type CentrifugoClientState, type CentrifugoConfig, type CentrifugoConnectionData, type CentrifugoContextValue, type CentrifugoErrorData, type CentrifugoErrorPayload, type CentrifugoEventDetail, type CentrifugoEventPayload, type CentrifugoEventType, type CentrifugoMessage, CentrifugoMonitor, CentrifugoMonitorDialog, CentrifugoMonitorFAB, type CentrifugoMonitorFABProps, type CentrifugoMonitorProps, CentrifugoMonitorWidget, type CentrifugoMonitorWidgetProps, CentrifugoProvider, type CentrifugoProviderProps, CentrifugoRPCClient, type CentrifugoToken, type CentrifugoVersionMismatchData, type ConnectionState, ConnectionStatus, ConnectionStatusCard, type ConnectionStatusCardProps, type ConnectionStatusProps, ConnectionTab, DEFAULT_RETRY_CONFIG, DebugPanel, type LogEntry, type LogLevel, LogsProvider, LogsTab, MessageFilters, type MessageFiltersProps, type MessageFilters$1 as MessageFiltersType, MessagesFeed, type MessagesFeedProps, type OpenMonitorDialogPayload, type PageVisibilityState, RPCError, type RPCErrorCode, type RetryConfig, type RetryState, SubscriptionsList, type SubscriptionsListProps, SubscriptionsTab, type UseNamedRPCOptions, type UseNamedRPCResult, type UsePageVisibilityOptions, type UsePageVisibilityResult, type UseRPCOptions, type UseRPCResult, type UseSubscriptionOptions, type UseSubscriptionResult, type User, type VersionMismatchPayload, calculateDelay, centrifugoConfig, consolaLogger, createLogger, createRetryHandler, dispatchCentrifugoError, dispatchCentrifugoEvent, dispatchConnected, dispatchDisconnected, dispatchReconnecting, dispatchVersionMismatch, emitCloseMonitorDialog, emitOpenMonitorDialog, getConsolaLogger, getGlobalLogsStore, isDevelopment, isProduction, isStaticBuild, sleep, useCentrifugo, useCodegenTip, useLogs, useNamedRPC, usePageVisibility, useRPC, useSubscription, withRetry };