import EventEmitter from 'node:events';
import type { IncomingMessage } from 'node:http';
import { type WebSocket, WebSocketServer } from 'ws';
import { type ExtendEventMap, type Frame, Session, type SessionEvents } from './base.js';
import { type ChatEventBody, type ChatEventFrameType, type CommandResponseBody, type DataFrameHeader, EncryptionMode, type EncryptResponseBody, type ErrorBody, type EventBody, type EventHeader, type EventResponsePurposes, type MinecraftAgentActionResponseHeader, type MinecraftAgentActionType, type MinecraftBlockData, type MinecraftDataType, type MinecraftItemData, type MinecraftMobData, ResponsePurpose } from './protocol.js';
import { MinecraftCommandVersion, Version } from './version.js';
export type CommandResponseFrame<B extends CommandResponseBody = CommandResponseBody> = Frame<ResponsePurpose.Command, B>;
export type ErrorFrame = Frame<ResponsePurpose.Error, ErrorBody>;
export declare class ClientError extends Error {
    frame: ErrorFrame;
    requestId: string;
    statusCode?: number;
    statusMessage?: string;
    constructor(frame: ErrorFrame);
}
export type EventFrameBase<B extends EventBody = EventBody> = Frame<EventResponsePurposes, B, EventHeader>;
export interface EventFrame<B extends EventBody = EventBody> extends EventFrameBase<B> {
    eventName: string;
}
export type AgentActionResponseFrameBase<B = unknown> = Frame<ResponsePurpose.AgentAction, B, MinecraftAgentActionResponseHeader>;
export interface AgentActionResponseFrame<B = unknown> extends AgentActionResponseFrameBase<B> {
    action: MinecraftAgentActionType;
    actionName: string;
    commandResponse?: CommandResponseFrame;
}
export type ChatEventFrameBase = Frame<ResponsePurpose.ChatMessage, ChatEventBody, EventHeader<ResponsePurpose.ChatMessage>>;
export interface ChatEventFrame extends ChatEventFrameBase {
    eventName: string;
    chatMessage: string;
    chatType: ChatEventFrameType;
    sender: string;
    receiver: string;
}
export type DataFrameBase<Name extends string = string, ReturnType = unknown> = Frame<ResponsePurpose.Data, ReturnType, DataFrameHeader<Name>>;
export interface DataFrame<Name extends string, ReturnType> extends DataFrameBase<Name, ReturnType> {
    dataType: Name;
}
export type EncryptResponseFrameBase = Frame<ResponsePurpose.EncryptConnection, EncryptResponseBody>;
type SemVer = string | [number, number, number];
export type CommandVersion = MinecraftCommandVersion | SemVer;
export interface ServerSessionEvents extends SessionEvents {
    event: [frame: EventFrame];
    commandResponse: [frame: CommandResponseFrame];
    clientError: [error: ClientError];
}
declare const ServerSession_base: ExtendEventMap<typeof Session, ServerSessionEvents>;
export declare class ServerSession extends ServerSession_base {
    server: WSServer;
    exchangingKey: boolean;
    private eventListeners;
    private chatResponsers;
    constructor(server: WSServer, socket: WebSocket);
    enableEncryption(callback?: (session: this) => void): boolean;
    enableEncryption(mode?: EncryptionMode, callback?: (session: this) => void): boolean;
    subscribeRaw(eventName: string): void;
    subscribe<B extends EventBody = EventBody>(eventName: string, callback: (frame: EventFrame<B>) => void): void;
    unsubscribeRaw(eventName: string): void;
    unsubscribe<B extends EventBody = EventBody>(eventName: string, callback: (frame: EventFrame<B>) => void): void;
    sendCommandRaw(requestId: string, command: string | string[], version?: CommandVersion): void;
    sendCommand<B extends CommandResponseBody = CommandResponseBody>(command: string | string[], callback?: (frame: CommandResponseFrame<B>) => void): `${string}-${string}-${string}-${string}-${string}`;
    sendCommandLegacyRaw(requestId: string, commandName: string, overload: string, input: Record<string, unknown>): void;
    sendCommandLegacy<B extends CommandResponseBody = CommandResponseBody>(commandName: string, overload: string, input: Record<string, unknown>, callback?: (frame: CommandResponseFrame<B>) => void): `${string}-${string}-${string}-${string}-${string}`;
    sendAgentCommandRaw(requestId: string, agentCommand: string | string[], version?: CommandVersion): void;
    sendAgentCommand<B = unknown>(command: string | string[], callback?: (frame: AgentActionResponseFrame<B>) => void): `${string}-${string}-${string}-${string}-${string}`;
    cancelCommandRequest(requestId: string): boolean;
    subscribeChatRaw(requestId: string, sender?: string | null, receiver?: string | null, message?: string | null): void;
    subscribeChat(sender?: string | null, receiver?: string | null, message?: string | null, callback?: (frame: ChatEventFrame) => void): `${string}-${string}-${string}-${string}-${string}`;
    unsubscribeChatRaw(requestId?: string): void;
    unsubscribeChat(requestId: string): void;
    unsubscribeChatAll(): void;
    fetchDataRaw(requestId: string, dataType: string): void;
    fetchData(dataType: MinecraftDataType.Block, callback?: (frame: DataFrame<MinecraftDataType.Block, MinecraftBlockData[]>) => void): string;
    fetchData(dataType: MinecraftDataType.Item, callback?: (frame: DataFrame<MinecraftDataType.Item, MinecraftItemData[]>) => void): string;
    fetchData(dataType: MinecraftDataType.Mob, callback?: (frame: DataFrame<MinecraftDataType.Mob, MinecraftMobData[]>) => void): string;
    fetchData<Name extends string, ReturnType>(dataType: Name, callback?: (frame: DataFrame<Name, ReturnType>) => void): string;
    sendEncryptionRequest(requestId: string, mode: EncryptionMode | number, publicKey: string, salt: string): void;
    disconnect(force?: boolean): void;
}
export interface ClientConnection {
    server: WSServer;
    session: ServerSession;
    request: IncomingMessage;
}
export interface WSServerEvents {
    client: [client: ClientConnection];
}
export declare class WSServer extends EventEmitter<WSServerEvents> {
    server: WebSocketServer;
    sessions: Set<ServerSession>;
    version: Version;
    constructor(port: number, handleClient?: (client: ClientConnection) => void);
    broadcastCommand(command: string, callback: (frame: CommandResponseFrame) => void): void;
    broadcastSubscribe(eventName: string, callback: (frame: EventFrame) => void): void;
    broadcastUnsubscribe(eventName: string, callback: (frame: EventFrame) => void): void;
    disconnectAll(force?: boolean): void;
    close(cb?: (err?: Error) => void): void;
}
export {};