export declare const Echo: typeof BroadcastClient;
/**
 * Client-side Broadcasting SDK
 *
 * A TypeScript/JavaScript client library for connecting to the broadcasting server
 */
export declare interface BroadcastClientConfig {
  broadcaster: 'bun' | 'reverb' | 'pusher' | 'ably'
  host?: string
  port?: number
  scheme?: 'ws' | 'wss'
  key?: string
  cluster?: string
  encrypted?: boolean
  auth?: {
    headers?: Record<string, string>
    endpoint?: string
  }
  autoConnect?: boolean
  reconnect?: boolean
  autoReconnect?: boolean
  reconnectDelay?: number
  reconnectInterval?: number
  maxReconnectAttempts?: number
  encryption?: {
    enabled?: boolean
    keys?: Record<string, string>
  }
  acknowledgments?: {
    enabled?: boolean
    timeout?: number
  }
  batch?: {
    enabled?: boolean
    maxBatchSize?: number
  }
  heartbeat?: {
    enabled?: boolean
    interval?: number
  }
  offlineQueue?: {
    enabled?: boolean
    maxSize?: number
  }
}
export declare interface ChannelCallbacks {
  subscription_succeeded?: (_data: any) => void
  subscription_error?: (error: any) => void
  [event: string]: EventCallback | undefined
}
export declare interface PresenceChannelCallbacks extends ChannelCallbacks {
  here?: (members: any[]) => void
  joining?: (member: any) => void
  leaving?: (member: any) => void
  error?: (error: any) => void
}
export declare interface PendingAcknowledgment {
  messageId: string
  resolve: (value: boolean) => void
  reject: (reason: Error) => void
  timeout: Timer
}
export type EventCallback<T = any> = (_data: T) => void;
// Aliases for backward compatibility (undocumented)
export type EchoConfig = BroadcastClientConfig;
/**
 * Connector class for managing WebSocket connection events
 */
export declare class Connector {
  on(event: string, callback: EventCallback): void;
  off(event: string, callback?: EventCallback): void;
  emit(event: string, data?: any): void;
}
export declare class BroadcastClient {
  connector: Connector;
  constructor(config: BroadcastClientConfig);
  connect(): void;
  disconnect(): void;
  isConnected(): boolean;
  socketId(): string | null;
  channel<T = any>(channelName: string): PublicChannel<T>;
  join<T = any>(channelName: string): PresenceChannel<T>;
  leave(channelName: string): void;
  leaveAll(): void;
  batchSubscribe(channelNames: string[], channelData?: Record<string, unknown>): Promise<{ succeeded: string[], failed: Record<string, string> }>;
  batchUnsubscribe(channelNames: string[]): Promise<{ succeeded: string[], failed: Record<string, string> }>;
  getSocketId(): string | null;
  setEncryptionKey(channel: string, key: string): void;
  getEncryptionKey(channel: string): string | undefined;
  sendWithAck(message: object, requireAck?: boolean): Promise<boolean>;
  listen(event: string, callback: EventCallback): void;
  stopListening(event: string, callback?: EventCallback): void;
  send(message: object): void;
}
/**
 * Base channel class
 */
export declare abstract class ChannelInstance<T = any> {
  protected client: BroadcastClient;
  protected name: string;
  protected callbacks: Map<string, Set<EventCallback<T>>>;
  isSubscribed: boolean;
  constructor(client: BroadcastClient, name: string);
  subscribe(): void;
  unsubscribe(): void;
  listen(event: string, callback: EventCallback<T>): this;
  stopListening(event: string, callback?: EventCallback<T>): this;
  handleEvent(event: string, data: any): void;
  getName(): string;
}
/**
 * Public channel
 */
export declare class PublicChannel<T = any> extends ChannelInstance<T> {
  subscribed(callback: () => void): this;
  error(callback: (error: any) => void): this;
}
/**
 * Private channel
 */
export declare class PrivateChannel<T = any> extends PublicChannel<T> {
  whisper(event: string, data: any): this;
  listenForWhisper(event: string, callback: EventCallback<T>): this;
}
/**
 * Presence channel
 */
export declare class PresenceChannel<T = any> extends PrivateChannel<T> {
  subscribe(): void;
  unsubscribe(): void;
  handleEvent(event: string, data: any): void;
  here(callback: (members: any[]) => void): this;
  joining(callback: (member: any) => void): this;
  leaving(callback: (member: any) => void): this;
  getMembers(): any[];
  getMember(id: string): any | null;
}
export default BroadcastClient;