/// <reference types="node" />
import { HAPEncryptionContext, HAPStates } from "./types/hap-proxy";
import { Socket } from "net";
import { HTTPRequest, HTTPRoutes, HTTPServerResponse } from "./lib/http-protocol";
import { EventEmitter } from "./lib/EventEmitter";
import { Advertiser } from "./lib/Advertiser";
import { AccessoryInfo } from "./storage/AccessoryInfo";
import { ParsedUrlQuery } from "querystring";
import { SrpServer } from "fast-srp-hap";
export declare type ServerPairSetupSession = {
    connection: HAPServerConnection;
    nextState: HAPStates;
    srpServer: SrpServer;
    sharedSecret: Buffer;
    sessionKey: Buffer;
    clientId: string;
    clientLTPK: Buffer;
};
export declare type ServerPairVerifySession = {
    nextState: HAPStates;
    secretKey: Buffer;
    publicKey: Buffer;
    clientPublicKey: Buffer;
    sharedSecret: Buffer;
    sessionKey: Buffer;
};
export declare type HTTPServerResponseCallback = (error?: Error, response?: HTTPServerResponse) => void;
export declare enum HAPServerEvents {
    CONNECTION = "connection",
    ACCESSORIES = "accessories",
    GET_CHARACTERISTICS = "get-characteristics",
    SET_CHARACTERISTICS = "set-characteristics",
    PREPARE_WRITE = "prepare",
    RESOURCE = "resource",
    PAIRED = "paired",
    UNPAIRED = "unpaired"
}
export declare type HAPServerEventMap = {
    [HAPServerEvents.CONNECTION]: (connection: HAPServerConnection) => void;
    [HAPServerEvents.ACCESSORIES]: (connection: HAPServerConnection, callback: HTTPServerResponseCallback) => void;
    [HAPServerEvents.GET_CHARACTERISTICS]: (connection: HAPServerConnection, query: ParsedUrlQuery, callback: HTTPServerResponseCallback) => void;
    [HAPServerEvents.SET_CHARACTERISTICS]: (connection: HAPServerConnection, writeRequest: Buffer, callback: HTTPServerResponseCallback) => void;
    [HAPServerEvents.PREPARE_WRITE]: (connection: HAPServerConnection, prepareRequest: Buffer, callback: HTTPServerResponseCallback) => void;
    [HAPServerEvents.RESOURCE]: (connection: HAPServerConnection, resourceRequest: Buffer, callback: HTTPServerResponseCallback) => void;
    [HAPServerEvents.PAIRED]: () => void;
    [HAPServerEvents.UNPAIRED]: () => void;
};
export declare class HAPServer extends EventEmitter<HAPServerEventMap> {
    accessoryInfo: AccessoryInfo;
    private tcpServer;
    private connections;
    advertiser: Advertiser;
    private routeHandlers;
    private currentPairSetupSession?;
    constructor(accessoryInfo: AccessoryInfo);
    listen(targetPort?: number): void;
    stop(): void;
    private handleListening;
    private handleConnection;
    private handleConnectionClosed;
    private handleClientUnpaired;
    private handleIdentify;
    private handlePair;
    private abortPairing;
    private handlePairM1;
    private handlePairM3;
    private handlePairM5;
    private generatePairM5Response;
    private handlePairVerify;
    private abortPairVerify;
    private handlePairVerifyM1;
    private handlePairVerifyM3;
    private handlePairings;
    private abortPairings;
    private addPairing;
    private removePairing;
    private listPairings;
    private handleAccessories;
    private handleCharacteristics;
    private handlePrepare;
    private handleResource;
}
export declare enum HAPServerConnectionEvents {
    DISCONNECTED = "disconnected"
}
export declare type HAPServerConnectionEventMap = {
    [HAPServerConnectionEvents.DISCONNECTED]: () => void;
};
export declare type HTTPRequestHandler = (connection: HAPServerConnection, request: HTTPRequest) => Promise<HTTPServerResponse>;
export declare const NOT_FOUND_HANDLER: HTTPRequestHandler;
export declare class HAPServerConnection extends EventEmitter<HAPServerConnectionEventMap> {
    private readonly socket;
    private readonly parser;
    private readonly routeHandler;
    sessionID: string;
    remoteAddress: string;
    pairVerifySession?: Partial<ServerPairVerifySession>;
    encryptionContext?: HAPEncryptionContext;
    clientId?: string;
    pairingVerified: boolean;
    private processingRequest;
    private disconnectAfterResponse;
    private socketClosed;
    private eventQueue;
    private httpWorkingQueue;
    constructor(socket: Socket, routeHandler: Record<HTTPRoutes, HTTPRequestHandler>);
    disconnect(): void;
    disconnectAfterWrite(): void;
    private handleData;
    private sendResponse;
    sendRawEvent(data: Buffer): void;
    flushEventQueue(): void;
    private handleClose;
    private handleError;
}
//# sourceMappingURL=HAPServer.d.ts.map