// Generated by dts-bundle v0.7.3
// Dependencies for this module:
//   ../net
//   ../events
//   ../json-helpers

import * as net from 'net';
import { EventEmitter } from 'events';
import { JSONLike } from 'json-helpers';

export class IpcSocket extends EventEmitter {
    constructor(options?: any);
    get socket(): net.Socket;
    get server(): net.Server;
    connect(portOrPath: any, host?: string): void;
    listen(portOrPath: any, host?: string): void;
    protected _parseStream(socket: net.Socket, server?: net.Server): void;
}

export class IpcPacketSocket extends IpcSocket {
    constructor(options?: any);
    protected _parseStream(socket: net.Socket, server?: net.Server): void;
}

export function WriteBuffersToSocket(socket: net.Socket, buffers: Buffer[]): void;
export interface SocketWriterBase {
    readonly socket: net.Socket;
}
export class SocketWriter extends BufferListWriterBase implements SocketWriterBase {
    constructor(socket: net.Socket);
    get socket(): net.Socket;
    get buffer(): Buffer;
    get buffers(): Buffer[];
    writeBuffers(buffers: Buffer[], totalLength?: number): number;
    protected _appendBuffer(buffer: Buffer, length: number): number;
    protected _appendBuffers(buffers: Buffer[], totalLength: number): number;
    reset(): void;
}

export class DelayedSocketWriter extends BufferListWriter implements SocketWriterBase {
    constructor(socket: net.Socket);
    get socket(): net.Socket;
    pushContext(): void;
    popContext(): void;
    protected flushBuffer(): void;
}
export class BufferedSocketWriter extends DelayedSocketWriter {
    constructor(socket: net.Socket, bufferSize?: number);
    pushContext(): void;
    popContext(): void;
}

export namespace IpcPacketBuffer {
    type RawData = IpcPacketBufferCore.RawData;
}
export class IpcPacketBuffer extends IpcPacketBufferCore {
    constructor(rawHeader?: IpcPacketBuffer.RawData);
    reset(): void;
    get buffer(): Buffer;
    get buffers(): Buffer[];
    setRawData(rawHeader: IpcPacketBuffer.RawData): void;
    getRawData(): IpcPacketBuffer.RawData;
    decodeFromReader(bufferReader: Reader): boolean;
    decodeFromBuffer(buffer: Buffer): boolean;
    protected _parseReader(): Reader;
    serialize(data: any): void;
}

export namespace IpcPacketBufferList {
    type RawContent = IpcPacketBufferCore.RawData;
}
export class IpcPacketBufferList extends IpcPacketBufferCore {
    constructor(rawHeader?: IpcPacketBufferList.RawContent);
    reset(): void;
    get buffers(): Buffer[];
    get buffer(): Buffer;
    setRawData(rawHeader: IpcPacketBufferList.RawContent): void;
    getRawData(): IpcPacketBufferList.RawContent;
    decodeFromReader(bufferReader: Reader): boolean;
    decodeFromBuffer(buffer: Buffer): boolean;
    protected _parseReader(): Reader;
    serialize(data: any): void;
}

export namespace IpcPacketBufferCore {
    interface RawData extends IpcPacketHeader.RawData {
        buffer?: Buffer;
        buffers?: Buffer[];
    }
}
export abstract class IpcPacketBufferCore extends IpcPacketCore {
    static readonly EmptyBuffer: Buffer;
    constructor(rawHeader?: IpcPacketBufferCore.RawData);
    abstract get buffer(): Buffer;
    abstract get buffers(): Buffer[];
    protected abstract _parseReader(): Reader;
    bytelength(data: any): number;
    parse<T = any>(): T | undefined;
    parseArrayLength(): number | undefined;
    parseArrayAt(index: number): any | undefined;
    parseArraySlice(start?: number, end?: number): any | undefined;
}

export class IpcPacketCore extends IpcPacketHeader {
    protected _reader: IpcPacketReader;
    protected _writer: IpcPacketWriter;
    get JSON(): JSONLike;
    set JSON(json: JSONLike);
    constructor(rawHeader?: IpcPacketHeader.RawData, reader?: IpcPacketReader, writer?: IpcPacketWriter);
    read(bufferReader: Reader): any | undefined;
    write(bufferWriter: Writer, data: any): void;
}

export namespace IpcPacketReader {
    type Callback = (rawHeader: IpcPacketHeader.RawData, arg?: any) => void;
}
export class IpcPacketReader extends IpcPacketJSON {
    constructor();
    read(bufferReader: Reader, cb?: IpcPacketReader.Callback): any | undefined;
    protected _read(bufferReader: Reader): any | undefined;
    readContent(bufferReader: Reader, type: IpcPacketType, contentSize: number): any | undefined;
    protected _readContentObject(bufferReader: Reader, contentSize: number): object;
    readContentArrayLength(bufferReader: Reader): number | undefined;
    readContentArrayAt(bufferReader: Reader, index: number): any | undefined;
    readContentArraySlice(bufferReader: Reader, start?: number, end?: number): any | undefined;
}

export const BufferFooter: Buffer;
export const BufferBooleanTrue: Buffer;
export const BufferBooleanFalse: Buffer;
export const BufferUndefined: Buffer;
export const BufferNull: Buffer;
export namespace IpcPacketWriter {
    type Callback = (rawHeader: IpcPacketHeader.RawData) => void;
}
export class IpcPacketWriter extends IpcPacketJSON {
    constructor();
    protected _writeDynamicBuffer(writer: Writer, type: IpcPacketType, buffer: Buffer, cb: IpcPacketWriter.Callback): void;
    protected _writeDynamicContent(writer: Writer, type: IpcPacketType, writerContent: Writer, cb: IpcPacketWriter.Callback): void;
    protected _writeFixedContent(writer: Writer, type: IpcPacketType, num: number, cb: IpcPacketWriter.Callback): void;
    write(bufferWriter: Writer, data: any, cb?: IpcPacketWriter.Callback): void;
    protected _writeNumber(bufferWriter: Writer, dataNumber: number, cb: IpcPacketWriter.Callback): void;
    protected _writeDate(bufferWriter: Writer, data: Date, cb: IpcPacketWriter.Callback): void;
    protected _writeString(bufferWriter: Writer, data: string, cb: IpcPacketWriter.Callback): void;
    protected _writeObject(bufferWriter: Writer, dataObject: any, cb: IpcPacketWriter.Callback): void;
    protected _writeArray(bufferWriter: Writer, args: any[], cb: IpcPacketWriter.Callback): void;
    protected _writeArrayBuffer(bufferWriter: Writer, data: ArrayBuffer, cb: IpcPacketWriter.Callback): void;
    protected _writeTypedArray(bufferWriter: Writer, data: any, arrayType: PossibleTypedArrays, cb: IpcPacketWriter.Callback): void;
}

export const HeaderSeparator: number;
export const FooterSeparator: number;
export const FooterLength = 1;
export const FixedHeaderSize = 2;
export const ContentFieldSize = 4;
export const ArrayFieldSize = 4;
export const DynamicHeaderSize: number;
export const DoubleContentSize = 8;
export const IntegerContentSize = 4;
export const ZeroContentSize = 0;
export enum IpcPacketType {
    NotValid,
    PartialHeader,
    PositiveInteger,
    NegativeInteger,
    ArrayWithSize,
    Buffer,
    ArrayBufferWithSize,
    Date,
    BooleanFalse,
    Null,
    Object,
    BooleanTrue,
    Undefined,
    Double,
    ObjectSTRINGIFY,
    String
}
export namespace IpcPacketHeader {
    interface RawData {
        type: IpcPacketType;
        headerSize: number;
        contentSize: number;
    }
}
export interface TypedArrayFactory {
    ctor: any;
    shortCode: number;
}
export const MapArrayBufferToShortCodes: Record<string, TypedArrayFactory>;
export const MapShortCodeToArrayBuffer: Record<number, TypedArrayFactory>;
export class IpcPacketHeader {
    protected _rawHeader: IpcPacketHeader.RawData;
    constructor(rawHeader?: IpcPacketHeader.RawData);
    reset(): void;
    setRawData(rawHeader: IpcPacketHeader.RawData): void;
    getRawData(): IpcPacketHeader.RawData;
    get type(): IpcPacketType;
    get packetSize(): number;
    get contentSize(): number;
    get footerSize(): number;
    get headerSize(): number;
    isNotValid(): boolean;
    isComplete(): boolean;
    isNull(): boolean;
    isUndefined(): boolean;
    isArray(): boolean;
    isObject(): boolean;
    isString(): boolean;
    isBuffer(): boolean;
    isDate(): boolean;
    isNumber(): boolean;
    isBoolean(): boolean;
    isFixedSize(): boolean;
    static DeclareHeader(type: IpcPacketType, contentSize: number): IpcPacketHeader.RawData;
    static ReadHeader(bufferReader: Reader): IpcPacketHeader.RawData;
}

export interface Writer {
    readonly buffer: Buffer;
    readonly buffers: Buffer[];
    readonly length: number;
    noAssert: boolean;
    reset(): void;
    writeByte(data: number): number;
    writeBytes(dataArray: number[]): number;
    writeUInt16(data: number): number;
    writeUInt32(data: number): number;
    writeDouble(data: number): number;
    writeString(data: string, len?: number): number;
    encodeString(data: string): Buffer;
    writeBuffer(data: Buffer, sourceStart?: number, sourceEnd?: number): number;
    writeBuffers(data: Buffer[]): number;
    writeArrayBuffer(data: ArrayBuffer): number;
    write(writer: Writer): number;
    pushContext(): void;
    popContext(): void;
}
export abstract class WriterBase implements Writer {
    protected static EmptyBuffer: Buffer;
    readonly encodeString: (data: string) => Buffer;
    protected _noAssert: boolean;
    constructor();
    abstract get buffer(): Buffer;
    abstract get buffers(): Buffer[];
    abstract get length(): number;
    get noAssert(): boolean;
    set noAssert(noAssert: boolean);
    abstract reset(): void;
    abstract writeByte(data: number): number;
    abstract writeBytes(dataArray: number[]): number;
    abstract writeUInt16(data: number): number;
    abstract writeUInt32(data: number): number;
    abstract writeDouble(data: number): number;
    abstract writeString(data: string, len?: number): number;
    abstract writeBuffer(data: Buffer, sourceStart?: number, sourceEnd?: number): number;
    abstract writeBuffers(data: Buffer[], totalLength?: number): number;
    abstract writeArrayBuffer(data: ArrayBuffer): number;
    abstract write(writer: Writer): number;
    abstract pushContext(): void;
    abstract popContext(): void;
}

export class BufferWriter extends WriterBase {
    constructor(buffer: Buffer, offset?: number);
    reset(): void;
    get buffer(): Buffer;
    get buffers(): Buffer[];
    get length(): number;
    get offset(): number;
    writeBytes(dataArray: number[]): number;
    writeByte(data: number): number;
    writeUInt16(data: number): number;
    writeUInt32(data: number): number;
    writeDouble(data: number): number;
    writeString(data: string, len?: number): number;
    writeBuffer(data: Buffer, sourceStart?: number, sourceEnd?: number): number;
    writeBuffers(buffers: Buffer[], totalLength?: number): number;
    writeArrayBuffer(data: ArrayBuffer): number;
    write(writer: Writer): number;
    pushContext(): void;
    popContext(): void;
}

export abstract class BufferListWriterBase extends WriterBase {
    protected _length: number;
    constructor();
    reset(): void;
    get length(): number;
    abstract readonly buffer: Buffer;
    abstract readonly buffers: Buffer[];
    protected abstract _appendBuffer(buffer: Buffer, length: number): number;
    protected abstract _appendBuffers(buffers: Buffer[], totalLength: number): number;
    writeBytes(dataArray: number[]): number;
    writeByte(data: number): number;
    writeUInt16(data: number): number;
    writeUInt32(data: number): number;
    writeDouble(data: number): number;
    writeString(data: string, len?: number): number;
    writeBuffer(buffer: Buffer, sourceStart?: number, sourceEnd?: number): number;
    writeBuffers(buffers: Buffer[], totalLength?: number): number;
    writeArrayBuffer(data: ArrayBuffer): number;
    write(writer: Writer): number;
    pushContext(): void;
    popContext(): void;
}
export class BufferListWriter extends BufferListWriterBase {
    protected _buffers: Buffer[];
    constructor();
    reset(): void;
    get buffer(): Buffer;
    get buffers(): Buffer[];
    protected _appendBuffer(buffer: Buffer, length: number): number;
    protected _appendBuffers(buffers: Buffer[], totalLength: number): number;
}

export namespace Reader {
    function AdjustEnd(offset: number, maxLen: number, len?: number): number;
}
export interface ReaderContext {
    offset: number;
}
export interface Reader {
    readonly length: number;
    readonly offset: number;
    noAssert: boolean;
    reset(): void;
    getContext(): ReaderContext;
    setContext(context: ReaderContext): void;
    pushd(): number;
    popd(): number;
    checkEOF(offsetStep?: number): boolean;
    skip(offsetStep?: number): boolean;
    seek(offset: number): boolean;
    readByte(): number;
    readUInt16(): number;
    readUInt32(): number;
    readDouble(): number;
    readString(encoding?: BufferEncoding, len?: number): string;
    readBuffer(len?: number): Buffer;
    readBufferList(len?: number): Buffer[];
    readArrayBuffer(len?: number): ArrayBuffer;
    slice(len?: number): Buffer;
    reduce(): void;
    subarray(len?: number): Buffer;
    subarrayList(len?: number): Buffer[];
}
export abstract class ReaderBase implements Reader {
    protected static EmptyBuffer: Buffer;
    protected readonly _decodeString: (buffer: Buffer, start: number, end: number) => string;
    protected _noAssert: boolean;
    protected _offset: number;
    constructor(offset?: number);
    abstract get length(): number;
    getContext(): ReaderContext;
    setContext(context: ReaderContext): void;
    get offset(): number;
    get noAssert(): boolean;
    set noAssert(noAssert: boolean);
    reset(): void;
    checkEOF(offsetStep?: number): boolean;
    skip(offsetStep?: number): boolean;
    abstract pushd(): number;
    abstract popd(): number;
    abstract seek(offset: number): boolean;
    abstract readByte(): number;
    abstract readUInt16(): number;
    abstract readUInt32(): number;
    abstract readDouble(): number;
    abstract readString(encoding?: BufferEncoding, len?: number): string;
    abstract readBuffer(len?: number): Buffer;
    abstract readBufferList(len?: number): Buffer[];
    abstract readArrayBuffer(len?: number): ArrayBuffer;
    abstract slice(len?: number): Buffer;
    abstract reduce(): void;
    subarray(len?: number): Buffer;
    subarrayList(len?: number): Buffer[];
    protected _decodeBufferFast(decoder: TextDecoder, buffer: Buffer, start: number, end: number): string;
    protected _decodeStringSlow(buffer: Buffer, start: number, end: number): string;
}

export class BufferReader extends ReaderBase {
    constructor(buffer: Buffer, offset?: number);
    reset(): void;
    get length(): number;
    pushd(): number;
    popd(): number;
    seek(offset: number): boolean;
    readByte(): number;
    readUInt16(): number;
    readUInt32(): number;
    readDouble(): number;
    readString(encoding?: BufferEncoding, len?: number): string;
    slice(len?: number): Buffer;
    readBuffer(len?: number): Buffer;
    readBufferList(len?: number): Buffer[];
    readArrayBuffer(len?: number): ArrayBuffer;
    reduce(): void;
}

export interface BufferListReaderContext extends ReaderContext {
    curBufferIndex: number;
    curOffset: number;
    timestamp: number;
}
export class BufferListReader extends ReaderBase {
    static readonly ReduceThreshold = 100000;
    constructor(buffers?: Buffer[], offset?: number);
    reset(): void;
    appendBuffer(buffer: Buffer): void;
    get length(): number;
    getContext(): BufferListReaderContext;
    setContext(context: BufferListReaderContext): void;
    pushd(): number;
    popd(): number;
    seek(offset: number): boolean;
    reduce(): void;
    readByte(): number;
    readUInt16(): number;
    readUInt32(): number;
    readDouble(): number;
    readString(_encoding?: BufferEncoding, len?: number): string;
    readBuffer(len?: number): Buffer;
    readBufferList(len?: number): Buffer[];
    readArrayBuffer(len?: number): ArrayBuffer;
    slice(len?: number): Buffer;
}

export class IpcPacketJSON {
    protected _json: JSONLike;
    constructor();
    get JSON(): JSONLike;
    set JSON(json: JSONLike);
}

export const typedArrays: readonly ["Int8Array", "Int16Array", "Int32Array", "Uint8Array", "Uint16Array", "Uint32Array", "Uint8ClampedArray", "BigInt64Array", "BigUint64Array", "Float32Array", "Float64Array"];
export type PossibleTypedArrays = typeof typedArrays[number];
export function getObjectStringTag(value: unknown): string | undefined;
export function whichTypedArray(value: unknown): PossibleTypedArrays | undefined;
export function isObject(arg: unknown): boolean;
export function isDate(d: unknown): boolean;
export function isArrayBuffer(value: unknown): boolean;