/**
 * Copyright (c) 2011 Bruno Jouhier <bruno.jouhier@sage.com>
 * MIT License
 */
/// <reference types="node" />
import * as http from 'http';
import * as https from 'https';
import * as net from 'net';
import { Reader } from './reader';
import { Writer } from './writer';
export interface Emitter extends NodeJS.EventEmitter {
    end?: (data?: any, encoding?: string) => void;
    close?: () => void;
    destroySoon?: () => void;
}
export declare class Wrapper<EmitterT extends Emitter> {
    _emitter: EmitterT;
    _closed: boolean;
    _onClose: (err?: Error) => void;
    _autoClosed: (() => void)[];
    _doesNotEmitClose: boolean;
    constructor(emitter: EmitterT);
    _trackClose(): void;
    close(): void;
    get closed(): boolean;
    unwrap(): EmitterT;
    get emitter(): EmitterT;
}
export interface ReadableOptions {
    lowMark?: number;
    highMark?: number;
    destroyOnStop?: boolean;
}
export declare type Data = string | Buffer;
export declare class ReadableStream<EmitterT extends NodeJS.ReadableStream> extends Wrapper<EmitterT> {
    _low: number;
    _high: number;
    _paused: boolean;
    _current: number;
    _chunks: Data[];
    _error: Error;
    _done: boolean;
    _encoding: string | null;
    _onData: (err?: Error, chunk?: Data) => void;
    _destroyOnClose: boolean;
    reader: Reader<any>;
    constructor(emitter: EmitterT, options?: ReadableOptions);
    _trackData(err: Error, chunk?: Data): void;
    _readChunk(): unknown;
    _concat(chunks: Data[], total: number): string | Buffer;
    setEncoding(enc: string | null): this;
    read(len?: number): any;
    readAll(): any;
    unread(chunk: Data): this;
    available(): number;
    stop(arg?: any): void;
    get events(): string[];
}
export interface WritableOptions {
    encoding?: string;
}
export declare class WritableStream<EmitterT extends NodeJS.WritableStream> extends Wrapper<EmitterT> {
    _error: Error;
    _onDrain: (err?: Error) => void;
    _encoding?: string;
    writer: Writer<any>;
    constructor(emitter: EmitterT, options?: WritableOptions);
    _drain(): void;
    write(data?: Data, enc?: string): this;
    end(data?: Data, enc?: string): this;
    get events(): string[];
}
export interface EncodingOptions {
    detectEncoding?: 'strict' | 'disable' | ((headers: http.IncomingHttpHeaders) => string);
}
export interface HttpServerOptions extends ReadableOptions, WritableOptions, EncodingOptions, https.ServerOptions {
    createServer?: (listener: (request: http.IncomingMessage, response: http.ServerResponse) => void) => http.Server | https.Server;
    secure?: boolean;
}
export declare class HttpServerRequest extends ReadableStream<http.IncomingMessage> {
    constructor(req: http.IncomingMessage, options?: HttpServerOptions);
    get method(): string;
    set method(val: string);
    get url(): string;
    set url(val: string);
    get headers(): any;
    set headers(val: any);
    get trailers(): any;
    set trailers(val: any);
    get rawHeaders(): string[];
    get rawTrailers(): string[];
    get httpVersion(): string;
    get connection(): net.Socket;
    get socket(): net.Socket;
    get statusCode(): number | undefined;
    get statusMessage(): string | undefined;
    get client(): any;
}
export declare class HttpServerResponse extends WritableStream<http.ServerResponse> {
    constructor(resp: http.ServerResponse, options?: HttpServerOptions);
    writeContinue(): this;
    writeHead(statusCode: number, headers?: any): this;
    setHeader(name: string, value: string | string[]): this;
    getHeader(name: string): string | number | string[] | undefined;
    removeHeader(name: string): this;
    addTrailers(trailers: any): this;
    get statusCode(): number;
    set statusCode(val: number);
    get statusMessage(): string;
    set statusMessage(val: string);
    get locals(): any;
}
export interface ServerEmitter extends Emitter {
    listen(...args: any[]): void;
}
export declare class Server<EmitterT extends ServerEmitter> extends Wrapper<EmitterT> {
    constructor(emitter: EmitterT);
    listen(...args: any[]): unknown;
}
export declare type HttpListener = (request: HttpServerRequest, response: HttpServerResponse) => void;
export declare function httpListener(listener: HttpListener, options: HttpServerOptions): (request: http.IncomingMessage, response: http.ServerResponse) => Promise<void>;
export declare function createHttpServer(requestListener: HttpListener, options: HttpServerOptions): HttpServer;
export declare class HttpServer extends Server<http.Server | https.Server> {
    constructor(requestListener: HttpListener, options: HttpServerOptions);
    setTimeout(msecs: number, callback: () => void): this;
}
export interface HttpClientResponseOptions extends ReadableOptions, WritableOptions, EncodingOptions {
}
export declare class HttpClientResponse extends ReadableStream<http.IncomingMessage> {
    constructor(resp: http.IncomingMessage, options?: HttpClientResponseOptions);
    get statusCode(): number | undefined;
    get statusMessage(): string | undefined;
    get httpVersion(): string;
    get headers(): http.IncomingHttpHeaders;
    get trailers(): {
        [key: string]: string | undefined;
    };
    get rawHeaders(): string[];
    get rawTrailers(): string[];
    checkStatus(statuses: number | number[]): this;
}
export interface HttpClientOptions extends HttpClientResponseOptions {
    url?: string;
    protocol?: string;
    host?: string;
    port?: string;
    path?: string;
    method?: string;
    headers?: http.IncomingHttpHeaders;
    module?: any;
    user?: string;
    password?: string;
    proxy?: any;
    proxyAuthenticate?: any;
    isHttps?: boolean;
    socket?: net.Socket;
    agent?: http.Agent | boolean;
}
export declare class HttpClientRequest extends WritableStream<http.ClientRequest> {
    _response: http.IncomingMessage;
    _done: boolean;
    _onResponse: (err: Error | undefined, response?: http.IncomingMessage) => void;
    _options: HttpClientOptions;
    constructor(options: HttpClientOptions);
    _trackResponse(err: Error | undefined, resp?: http.IncomingMessage): void;
    _responseCb(callback: (err?: Error, resp?: http.IncomingMessage) => void): void;
    response(): HttpClientResponse;
    setTimeout(ms: number): this;
    proxyConnect(): this;
}
export declare class HttpProxyClientRequest {
    _options: HttpClientOptions;
    constructor(options: HttpClientOptions);
    proxyConnect(): HttpClientRequest;
    response(): void;
}
export declare function httpRequest(options: HttpClientOptions): HttpProxyClientRequest | HttpClientRequest;
export interface SocketOptions extends ReadableOptions, WritableOptions {
    read?: ReadableOptions;
    write?: WritableOptions;
}
export declare class SocketStream extends ReadableStream<net.Socket & NodeJS.ReadableStream> {
    _writableStream: WritableStream<net.Socket>;
    constructor(emitter: net.Socket, options?: SocketOptions);
    write(data?: Data, enc?: string): this;
    end(data?: Data, enc?: string): this;
    get writer(): Writer<any>;
    setTimeout(ms: number, callback?: Function): this;
    setNoDelay(noDelay?: boolean): this;
    setKeepAlive(enable?: boolean): this;
    ref(): this;
    unref(): this;
    destroy(): this;
    address(): {
        port: number;
        family: string;
        address: string;
    };
    get localAddress(): string;
    get localPort(): number;
    get remoteAddress(): string | undefined;
    get remotePort(): number | undefined;
}
export declare function tcpClient(port: number, host?: string, options?: SocketOptions): SocketClient;
export declare function socketClient(path: string, options?: SocketOptions): SocketClient;
export declare class SocketClient {
    _options?: SocketOptions;
    _connection: net.Socket;
    _error: Error;
    _done: boolean;
    _onConnect: (err?: Error) => void;
    constructor(options?: SocketOptions, ...args: any[]);
    _trackConnect(err?: Error): void;
    connect(callback: (err?: Error, stream?: SocketStream) => void): void;
}
export interface SocketServerOptions {
}
export declare type SocketServerListener = (stream: SocketStream) => void;
export declare function createNetServer(serverOptions: SocketServerOptions, connectionListener: SocketServerListener, streamOptions: SocketOptions): SocketServer;
export declare class SocketServer extends Server<net.Server> {
    constructor(serverOptions: SocketServerOptions, connectionListener: SocketServerListener, streamOptions: SocketOptions);
}