export = HttpWsProtocol;
/**
 * @class HTTPWS
 * Handles both HTTP and WebSocket connections
 */
declare class HttpWsProtocol extends Protocol {
    constructor();
    server: uWS.TemplatedApp;
    wsConfig: {
        enabled: boolean;
        opts?: undefined;
        rateLimit?: undefined;
    } | {
        enabled: any;
        opts: {
            compression: number;
            idleTimeout: number;
            maxPayloadLength: number;
            resetIdleTimeoutOnSend: any;
            sendPingsAutomatically: any;
        };
        rateLimit: any;
    };
    httpConfig: {
        enabled: boolean;
        headers?: undefined;
        opts?: undefined;
    } | {
        enabled: any;
        headers: string[][];
        opts: {
            allowCompression: any;
            allowedContentTypes: any[];
            maxEncodingLayers: any;
            maxFormFileSize: any;
        };
    };
    now: number;
    nowInterval: NodeJS.Timeout;
    connectionBySocket: Map<any, any>;
    backpressureBuffer: Map<any, any>;
    socketByConnectionId: Map<any, any>;
    logger: import("../../../kuzzle/Logger").Logger;
    init(entrypoint: any): Promise<boolean>;
    initWebSocket(): void;
    initHttp(): void;
    broadcast(data: any): void;
    notify(data: any): void;
    joinChannel(channel: any, connectionId: any): void;
    leaveChannel(channel: any, connectionId: any): void;
    disconnect(connectionId: any, message?: any): void;
    wsOnUpgradeHandler(res: any, req: any, context: any): void;
    wsOnOpenHandler(socket: any): void;
    wsOnCloseHandler(socket: any, code: any, message: any): void;
    wsOnMessageHandler(socket: any, data: any): Promise<void>;
    /**
     * Absorb as much of the backpressure buffer as possible
     * @param  {uWS.WebSocket} socket
     */
    wsOnDrainHandler(socket: uWS.WebSocket<any>): void;
    /**
     * Forwards an error to a socket
     *
     * @param  {uWS.WebSocket} socket
     * @param  {ClientConnection} connection
     * @param  {Error} error
     * @param  {String} requestId @optional
     */
    wsSendError(socket: uWS.WebSocket<any>, connection: ClientConnection, error: Error, requestId: string): void;
    /**
     * Sends a message immediately, or queue it up for later if backpressure built
     * up
     *
     * @param  {uWS.WebSocket} socket
     * @param  {Buffer} payload
     */
    wsSend(socket: uWS.WebSocket<any>, payload: Buffer): void;
    /**
     * @param  {uWS.HttpResponse} response
     * @param  {uWS.HttpRequest} request
     */
    httpOnMessageHandler(response: uWS.HttpResponse, request: uWS.HttpRequest): void;
    /**
     * Read an HTTP payload data
     *
     * @param  {HttpMessage} message
     * @param  {uWS.HttpResponse} response
     * @param  {Function} cb
     */
    httpReadData(message: HttpMessage, response: uWS.HttpResponse, cb: Function): void;
    httpParseContent(message: any, content: any, cb: any): Promise<void>;
    httpProcessRequest(response: any, message: any): void;
    /**
     *
     * @param {uWS.HttpRequest} request
     * @param {uWS.HttpResponse} response
     * @param {HttpMessage} message
     */
    httpWriteRequestHeaders(request: uWS.HttpRequest, response: uWS.HttpResponse, message: HttpMessage): void;
    /**
     * Send stream data thorugh the HTTP response
     * @param {HttpRequest} request
     * @param {HttpStream} httpStream - The data stream to send
     * @param {uWS.HttpResponse} response
     * @param {HttpMessage} message
     */
    httpSendStream(request: HttpRequest, response: uWS.HttpResponse, httpStream: HttpStream, message: HttpMessage): void;
    /**
     * Forward an error response to the client
     *
     * @param {HttpMessage} message
     * @param {uWS.HttpResponse} response
     * @param {Error} error
     */
    httpSendError(message: HttpMessage, response: uWS.HttpResponse, error: Error): void;
    /**
     * Convert a Kuzzle query result into an appropriate payload format
     * to send back to the client
     *
     * @param {Request} request
     * @param {HttpMessage} message
     * @returns {Buffer}
     */
    httpRequestToResponse(request: Request, message: HttpMessage): Buffer;
    /**
     * Compress an outgoing message according to the
     * specified accept-encoding HTTP header
     *
     * @param  {HttpMessage} message
     * @param  {Buffer} data
     * @param  {Function} callback
     */
    httpCompress(message: HttpMessage, data: Buffer, callback: Function): void;
    httpUncompress(message: any, payload: any, cb: any): void;
    httpUncompressStep(encodings: any, payload: any, cb: any, index: any): void;
    parseWebSocketOptions(): {
        enabled: boolean;
        opts?: undefined;
        rateLimit?: undefined;
    } | {
        enabled: any;
        opts: {
            compression: number;
            idleTimeout: number;
            maxPayloadLength: number;
            resetIdleTimeoutOnSend: any;
            sendPingsAutomatically: any;
        };
        rateLimit: any;
    };
    parseHttpOptions(): {
        enabled: boolean;
        headers?: undefined;
        opts?: undefined;
    } | {
        enabled: any;
        headers: string[][];
        opts: {
            allowCompression: any;
            allowedContentTypes: any[];
            maxEncodingLayers: any;
            maxFormFileSize: any;
        };
    };
}
import Protocol = require("./protocol");
import uWS = require("uWebSockets.js");
import ClientConnection = require("../clientConnection");
import HttpMessage = require("./httpMessage");
import { HttpStream } from "../../../types/HttpStream";
import { Request } from "../../../api/request/kuzzleRequest";