import { AcknowledgmentManager } from './acknowledgments';
import { AuthenticationManager, MessageValidationManager, MonitoringManager, RateLimiter, SecurityManager } from './middleware';
import { BatchOperationsManager } from './batch-operations';
import { Broadcaster } from './broadcaster';
import { BroadcastHelpers } from './helpers';
import { ChannelLifecycleManager } from './lifecycle-hooks';
import { ChannelManager } from './channels';
import { ChannelNamespaceManager, ChannelStateManager } from './channel-state';
import { EncryptionManager } from './encryption';
import { LoadManager } from './load-management';
import { PersistenceManager } from './persistence';
import { PresenceHeartbeatManager } from './presence-heartbeat';
import { RedisAdapter } from './redis-adapter';
import { WebhookManager } from './webhooks';
import type { AckConfig } from './acknowledgments';
import type { AuthConfig, RateLimitConfig, SecurityConfig } from './middleware';
import type { BatchConfig } from './batch-operations';
import type { BroadcastConfig, ConnectionOptions, User } from './types';
import type { EncryptionConfig } from './encryption';
import type { HeartbeatConfig } from './presence-heartbeat';
import type { LoadConfig } from './load-management';
import type { PersistenceConfig } from './persistence';
import type { RedisConfig } from './redis-adapter';
import type { WebhookConfig } from './webhooks';
/**
 * The `/stats` and `/metrics` HTTP endpoints. Both report connection and
 * channel counts and process details, and the server binds 0.0.0.0 by
 * default, so they are off unless enabled here.
 */
export declare interface EndpointsConfig {
  stats?: boolean
  metrics?: boolean
  token?: string
}
/**
 * A broadcast about to be sent: what `server.broadcast()` was called with.
 */
export declare interface OutboundBroadcast {
  channel: string
  event: string
  data: unknown
}
export declare interface ServerConfig extends BroadcastConfig {
  host?: string
  port?: number
  websocket?: ConnectionOptions
  beforeBroadcast?: BroadcastHook
  redis?: RedisConfig
  auth?: AuthConfig
  authorizeConnection?: ConnectionAuthorizer
  endpoints?: EndpointsConfig
  rateLimit?: RateLimitConfig
  security?: SecurityConfig
  debug?: boolean
  encryption?: EncryptionConfig
  webhooks?: WebhookConfig
  persistence?: PersistenceConfig
  heartbeat?: HeartbeatConfig
  acknowledgments?: AckConfig
  batch?: BatchConfig
  loadManagement?: LoadConfig
  queue?: {
    enabled?: boolean
    connection?: string
    defaultQueue?: string
    retry?: {
      attempts?: number
      backoff?: {
        type: 'fixed' | 'exponential'
        delay: number
      }
    }
    deadLetter?: {
      enabled?: boolean
      maxRetries?: number
    }
  }
}
/**
 * What `authorizeConnection` may return. `true`/`false` accept or refuse
 * with a 401; the object form picks the status and message of a refusal,
 * or, when accepting, replaces the authenticated user and attaches extra
 * per-socket data (`ws.data.user` / `ws.data.data`).
 */
export type ConnectionAuthorizationResult = | boolean
  | { ok: true, user?: User | null, data?: Record<string, unknown> }
  | { ok: false, status?: number, message?: string }
/**
 * Decides whether a WebSocket upgrade on `/app` or `/ws` goes through. It
 * runs after `auth` (so `user` is whatever `auth` resolved, or null) and
 * before the socket exists. A hook that throws refuses the upgrade with a
 * 500, and one that returns nothing refuses it with a 401: a broken
 * authorizer fails closed.
 */
export type ConnectionAuthorizer = (
  req: Request,
  user: User | null,
) => ConnectionAuthorizationResult | void | Promise<ConnectionAuthorizationResult | void>;
/**
 * Runs for every broadcast, from every API (`server.broadcast()`, the
 * broadcaster, the facade, queued jobs, Redis-relayed messages), before the
 * frame is serialized. It runs even when no local socket is subscribed, so
 * it sees every message, not every delivery. The object it returns is
 * merged into the frame as extra top-level fields beside `event`, `channel`
 * and `data` (which it cannot overwrite), e.g. a sequence number clients
 * read as `message.seq`. A hook that throws is logged and skipped; the
 * broadcast still goes out.
 */
export type BroadcastHook = (message: OutboundBroadcast) => Record<string, unknown> | void;
export declare class BroadcastServer {
  channels: ChannelManager;
  broadcaster: Broadcaster;
  helpers: BroadcastHelpers;
  redis?: RedisAdapter;
  auth?: AuthenticationManager;
  rateLimit?: RateLimiter;
  monitoring?: MonitoringManager;
  validator?: MessageValidationManager;
  security?: SecurityManager;
  encryption?: EncryptionManager;
  webhooks?: WebhookManager;
  persistence?: PersistenceManager;
  channelState?: ChannelStateManager;
  namespace?: ChannelNamespaceManager;
  presenceHeartbeat?: PresenceHeartbeatManager;
  acknowledgments?: AcknowledgmentManager;
  batchOps?: BatchOperationsManager;
  lifecycle?: ChannelLifecycleManager;
  loadManager?: LoadManager;
  queueManager?: any // Will be typed as BroadcastQueueManager;
  constructor(config: ServerConfig);
  start(): Promise<void>;
  addBroadcastHook(hook: BroadcastHook): () => void;
  stop(): Promise<void>;
  broadcast(channel: string, event: string, data: unknown, exclude?: string | string[]): void;
  getConnectionCount(): number;
  getSubscriberCount(channel: string): number;
  getStats(): Promise<Record<string, any>>;
}