import ServerOptions from "./ServerOptions";
import { OriginsChecker } from "./OriginsChecker";
import AuthEngine from "./AuthEngine";
import Socket from "./Socket";
import EventEmitter from "emitix";
import ChannelExchange from "./ChannelExchange";
import InternalBroker from "./broker/InternalBroker";
import { HttpResponse } from "./http/EnhanceHttpResponse";
import UpgradeRequest from "./http/UpgradeRequest";
import { BatchOption, ComplexTypesOption } from "ziron-engine";
import { SkipGroupMemberOption } from "./Options";
import { HttpRequest } from "./http/EnhanceHttpRequest";
type LocalEvents<S extends Socket> = {
    'error': [Error];
    'warning': [Error];
    'badSocketAuthToken': [S, Error, string];
    'disconnection': [S, number, any];
};
type UpgradeMiddleware = (req: UpgradeRequest) => Promise<void> | void;
type SocketMiddleware<S extends Socket> = (socket: S) => Promise<void> | void;
type AuthenticateMiddleware<S extends Socket> = (socket: S, authToken: object, signedAuthToken: string) => Promise<void> | void;
type SubscribeMiddleware<S extends Socket> = (socket: S, channel: string) => Promise<void> | void;
type PublishInMiddleware<S extends Socket> = (socket: S, channel: string, data: any) => Promise<void> | void;
/**
 * @description
 * The Ziron server.
 * Mostly everything is related to web socket protocol on the server instance.
 * But an HTTP/HTTPS server is created to catch upgrade requests and to create a health endpoint.
 * All other HTTP requests will be answered with 426 (Upgrade Required),
 * but it is possible to provide a custom HTTP request handler.
 */
export default class Server<E extends {
    [key: string]: any[];
} = {}, ES extends Socket = Socket> {
    private readonly _compressionOptions;
    readonly originsChecker: OriginsChecker;
    readonly auth: AuthEngine;
    get id(): string;
    get port(): number;
    get path(): string;
    get tls(): boolean;
    private _authTokenExpireCheckerTicker;
    private _pingTicker;
    private _listenToken?;
    private _startListenPromise?;
    private readonly _groupTransport;
    protected emitter: (EventEmitter<LocalEvents<ES>> & EventEmitter<E>);
    readonly once: (EventEmitter<LocalEvents<ES>> & EventEmitter<E>)['once'];
    readonly on: (EventEmitter<LocalEvents<ES>> & EventEmitter<E>)['on'];
    readonly off: (EventEmitter<LocalEvents<ES>> & EventEmitter<E>)['off'];
    /**
     * @description
     * The connected web socket clients count.
     */
    readonly clientCount: number;
    /**
     * @description
     * The connected web socket clients.
     */
    readonly clients: Record<string, ES>;
    /**
     * @description
     * This is a counter of WebSocket messages.
     * You can reset this counter with the resetWsMessageCount method.
     */
    readonly wsMessageCount: number;
    /**
     * @description
     * This is a counter of received invoke messages.
     * You can reset this counter with the resetInvokeMessageCount method.
     */
    readonly invokeMessageCount: number;
    /**
     * @description
     * This is a counter of received transmit messages.
     * You can reset this counter with the resetTransmitMessageCount method.
     */
    readonly transmitMessageCount: number;
    /**
     * @description
     * This is a counter of HTTP messages.
     * You can reset this counter with the resetHttpMessageCount method.
     */
    readonly httpMessageCount: number;
    /**
     * @description
     * Specify a socket constructor extension.
     * This extension will be called in the socket constructor and
     * can be used to add properties to the Socket instance.
     * Use this extension only when you know what you are doing.
     * It is also recommended specifying this new Socket type at the
     * generic ES (extended socket) parameter of the Server class.
     * This approach is implemented rather than a custom Socket class to prevent
     * a larger proto chain and for the ability to add external variables into the constructor easily.
     */
    socketConstructorExtension: (socket: Socket) => void;
    /**
     * @description
     * The connection handler will be called when a new socket is connected.
     * The handler can be used to register receivers or procedures on the socket.
     * The returned value will be transmitted to the client.
     * Promises are considered, and the connection is only ready when the promise is resolved.
     */
    connectionHandler: (socket: ES) => Promise<any> | any;
    /**
     * @description
     * Set this property to handle HTTP requests.
     * Notice that firstly Ziron checks the origin and catches and processes health endpoint requests.
     * The handler will be called when the request is not answered after the Ziron pipeline.
     * If the response is still available after the Ziron pipeline and
     * the handler call Ziron responds with a 426 (Upgrade Required) response.
     */
    httpRequestHandler?: (req: HttpRequest, res: HttpResponse) => Promise<any> | any;
    /**
     * @description
     * Specify a custom health check.
     * This health check is used to process the value for the health endpoint.
     * This endpoint could be used for docker health checks.
     */
    healthCheck: () => Promise<boolean> | boolean;
    upgradeMiddleware: UpgradeMiddleware | undefined;
    socketMiddleware: SocketMiddleware<ES> | undefined;
    authenticateMiddleware: AuthenticateMiddleware<ES> | undefined;
    subscribeMiddleware: SubscribeMiddleware<ES> | undefined;
    publishInMiddleware: PublishInMiddleware<ES> | undefined;
    protected readonly internalBroker: InternalBroker;
    readonly channels: ChannelExchange;
    /**
     * @description
     * Boolean that indicates if the server should reject web socket handshakes.
     */
    refuseConnections: boolean;
    ignoreFurtherTransmits: boolean;
    ignoreFurtherInvokes: boolean;
    constructor(options?: ServerOptions);
    private _createGroupTransport;
    private _createTransportOptions;
    private _loadCompressionOptions;
    private _setUpSocketChLimit;
    private _setUpApp;
    private _startPingInterval;
    private _startAuthExpireCheck;
    private static _abortUpgrade;
    private _handleUpgrade;
    private _handleWsOpen;
    private _handleWsMessage;
    private static _handleWsDrain;
    private static _handleWsClose;
    private _setupHttpRequestHandling;
    private _processHttpHealthCheckRequest;
    /**
     * @description
     * Sends a transmit to a group.
     * Instead of channels, groups can only be accessed and controlled from the server-side and
     * messages are not shared across multiple server instances.
     * Groups don't have their own special protocol and can be used to send a standard
     * transmit optimized to multiple sockets of a group.
     * Additionally, the group transmits support batching when not using the skipMember option.
     * When using the skipMember option, the batch option will be ignored.
     * Internally prepareMultiTransmit is used to create the transmit packet,
     * so binary data is supported.
     * @param group
     * @param receiver
     * @param data
     * @param options
     */
    transmitToGroup(group: string, receiver: string, data?: any, options?: ComplexTypesOption & BatchOption & SkipGroupMemberOption): void;
    /**
     * @description
     * Returns the member count of a specific group from this server instance.
     * Instead of channels, groups can only be accessed and controlled from the server-side and
     * messages are not shared across multiple server instances.
     * Groups don't have their own special protocol and can be used to send a standard
     * transmit optimized to multiple sockets of a group.
     * Additionally, the group transmits support batching when not using the skipMember option.
     * Internally prepareMultiTransmit is used to create the transmit packet,
     * so binary data is supported.
     * @param group
     */
    getGroupMemberCount(group: string): number;
    listen(): Promise<void>;
    getInternalSubscriptions(): string[];
    resetWsMessageCount(): void;
    resetInvokeMessageCount(): void;
    resetTransmitMessageCount(): void;
    resetHttpMessageCount(): void;
    /**
     * @description
     * Resets all counts (wsMessageCount,invokeMessageCount,transmitMessageCount and httpMessageCount).
     */
    resetCounts(): void;
    stopListen(): void;
    isListening(): boolean;
    /**
     * Terminates the server.
     * After termination, you should not use this instance anymore
     * or anything else from the server.
     * [Use this method only when you know what you do.]
     */
    terminate(): void;
}
export {};