/**
 * represent compression stream writer
 * ```typescript
 * let compressedWriter = new CompressedStreamWriter();
 * let text: string = 'Hello world!!!';
 * compressedWriter.write(text, 0, text.length);
 * compressedWriter.close();
 * ```
 */
export declare class CompressedStreamWriter {
    static isHuffmanTreeInitiated: boolean;
    stream: Uint8Array[];
    pendingBuffer: Uint8Array;
    pendingBufLength: number;
    pendingBufCache: number;
    pendingBufBitsInCache: number;
    treeLiteral: CompressorHuffmanTree;
    treeDistances: CompressorHuffmanTree;
    treeCodeLengths: CompressorHuffmanTree;
    bufferPosition: number;
    arrLiterals: Uint8Array;
    arrDistances: Uint16Array;
    extraBits: number;
    currentHash: number;
    hashHead: Int16Array;
    hashPrevious: Int16Array;
    matchStart: number;
    matchLength: number;
    matchPrevAvail: boolean;
    blockStart: number;
    stringStart: number;
    lookAhead: number;
    dataWindow: Uint8Array;
    inputBuffer: Uint8Array;
    totalBytesIn: number;
    inputOffset: number;
    inputEnd: number;
    windowSize: number;
    windowMask: number;
    hashSize: number;
    hashMask: number;
    hashShift: number;
    maxDist: number;
    checkSum: number;
    noWrap: boolean;
    /**
     * get compressed data
      * @returns {Uint8Array[]} The result.
 */
    readonly compressedData: Uint8Array[];
    /**
     * getCompressedString.
     * @returns {string} The result.
     */
    readonly getCompressedString: string;
    /**
     * Initializes compressor and writes ZLib header if needed.
     * @param {boolean} noWrap - optional if true, ZLib header and checksum will not be written.
     */
    constructor(noWrap?: boolean);
    /**
     * Compresses data and writes it to the stream.
     * @param {string | Uint8Array} data - data to compress
     * @param {number} offset - offset in data
     * @param {number} length - length of the data
     * @returns {void} The result.
     */
    write(data: string | Uint8Array, offset: number, length: number): void;
    /**
     * write ZLib header to the compressed data
     * @returns {void} The result.
     */
    writeZLibHeader(): void;
    /**
     *  Write Most Significant Bytes in to stream
     * @param {number} s - check sum value
      * @returns {void} Nothing.
 */
    pendingBufferWriteShortBytes(s: number): void;
    /**
     * compressData.
     * @param {boolean} finish - The finish parameter.
     * @returns {boolean} The result.
     */
    compressData(finish: boolean): boolean;
    /**
     * compressSlow.
     * @param {boolean} flush - The flush parameter.
     * @param {boolean} finish - The finish parameter.
     * @returns {boolean} The result.
     */
    compressSlow(flush: boolean, finish: boolean): boolean;
    /**
     * discardMatch.
     * @returns {void} Nothing.
     */
    discardMatch(): void;
    /**
     * matchPreviousAvailable.
     * @returns {void} Nothing.
     */
    matchPreviousAvailable(): void;
    /**
     * matchPreviousBest.
     * @param {number} prevMatch - The prevMatch parameter.
     * @param {number} prevLen - The prevLen parameter.
     * @returns {number} The result.
     */
    matchPreviousBest(prevMatch: number, prevLen: number): number;
    /**
     * lookAheadCompleted.
     * @param {boolean} finish - The finish parameter.
     * @returns {boolean} The result.
     */
    lookAheadCompleted(finish: boolean): boolean;
    /**
     * huffmanIsFull.
     * @param {boolean} finish - The finish parameter.
     * @returns {boolean} The result.
     */
    huffmanIsFull(finish: boolean): boolean;
    /**
     * fillWindow.
     * @returns {void} Nothing.
     */
    fillWindow(): void;
    /**
     * slideWindow.
     * @returns {void} Nothing.
     */
    slideWindow(): void;
    /**
     * insertString.
     * @returns {number} The result.
     */
    insertString(): number;
    /**
     * findLongestMatch.
     * @param {number} curMatch - The curMatch parameter.
     * @returns {boolean} The result.
     */
    findLongestMatch(curMatch: number): boolean;
    /**
     * updateHash.
     * @returns {void} Nothing.
     */
    updateHash(): void;
    /**
     * huffmanTallyLit.
     * @param {number} literal - The literal parameter.
     * @returns {boolean} The result.
     */
    huffmanTallyLit(literal: number): boolean;
    /**
     * huffmanTallyDist.
     * @param {number} dist - The dist parameter.
     * @param {number} len - The len parameter.
     * @returns {boolean} The result.
     */
    huffmanTallyDist(dist: number, len: number): boolean;
    /**
     * huffmanFlushBlock.
     * @param {Uint8Array} stored - The stored parameter.
     * @param {number} storedOffset - The storedOffset parameter.
     * @param {number} storedLength - The storedLength parameter.
     * @param {boolean} lastBlock - The lastBlock parameter.
     * @returns {void} Nothing.
     */
    huffmanFlushBlock(stored: Uint8Array, storedOffset: number, storedLength: number, lastBlock: boolean): void;
    /**
     * huffmanFlushStoredBlock.
     * @param {Uint8Array} stored - The stored parameter.
     * @param {number} storedOffset - The storedOffset parameter.
     * @param {number} storedLength - The storedLength parameter.
     * @param {boolean} lastBlock - The lastBlock parameter.
     * @returns {void} Nothing.
     */
    huffmanFlushStoredBlock(stored: Uint8Array, storedOffset: number, storedLength: number, lastBlock: boolean): void;
    /**
     * huffmanLengthCode.
     * @param {number} len - The len parameter.
     * @returns {number} The result.
     */
    huffmanLengthCode(len: number): number;
    /**
     * huffmanDistanceCode.
     * @param {number} distance - The distance parameter.
     * @returns {number} The result.
     */
    huffmanDistanceCode(distance: number): number;
    /**
     * huffmanSendAllTrees.
     * @param {number} blTreeCodes - The blTreeCodes parameter.
     * @returns {void} Nothing.
     */
    huffmanSendAllTrees(blTreeCodes: number): void;
    /**
     * huffmanReset.
     * @returns {void} Nothing.
     */
    huffmanReset(): void;
    /**
     * huffmanCompressBlock.
     * @returns {void} Nothing.
     */
    huffmanCompressBlock(): void;
    /**
     * write bits in to internal buffer
     * @param {number} b - source of bits
     * @param {number} count - count of bits to write
      * @returns {void} Nothing.
 */
    pendingBufferWriteBits(b: number, count: number): void;
    /**
     * pendingBufferFlush.
     * @param {boolean} isClose - The isClose parameter.
     * @returns {void} Nothing.
     */
    pendingBufferFlush(isClose?: boolean): void;
    /**
     * pendingBufferFlushBits.
     * @returns {number} The result.
     */
    pendingBufferFlushBits(): number;
    /**
     * pendingBufferWriteByteBlock.
     * @param {Uint8Array} data - The data parameter.
     * @param {number} offset - The offset parameter.
     * @param {number} length - The length parameter.
     * @returns {void} Nothing.
     */
    pendingBufferWriteByteBlock(data: Uint8Array, offset: number, length: number): void;
    /**
     * pendingBufferWriteShort.
     * @param {number} s - The s parameter.
     * @returns {void} Nothing.
     */
    pendingBufferWriteShort(s: number): void;
    /**
     * pendingBufferAlignToByte.
     * @returns {void} Nothing.
     */
    pendingBufferAlignToByte(): void;
    /**
     * Huffman Tree literal calculation
     * @private
      * @returns {void} Nothing.
 */
    static initHuffmanTree(): void;
    /**
     * close the stream and write all pending buffer in to stream
     * @returns {void} The result.
     */
    close(): void;
    /**
     * release allocated un-managed resource
     * @returns {void} The result.
     */
    destroy(): void;
}
/**
 * represent the Huffman Tree
 */
export declare class CompressorHuffmanTree {
    codeFrequency: Uint16Array;
    codes: Int16Array;
    codeLength: Uint8Array;
    lengthCount: Int32Array;
    codeMinCount: number;
    codeCount: number;
    maxLength: number;
    writer: CompressedStreamWriter;
    static reverseBits: number[];
    static huffCodeLengthOrders: number[];
    /**
     * treeLength.
     * @returns {number} The result.
     */
    readonly treeLength: number;
    /**
     * codeLengths.
     * @returns {Uint8Array} The result.
     */
    readonly codeLengths: Uint8Array;
    /**
     * codeFrequencies.
     * @returns {Uint16Array} The result.
     */
    readonly codeFrequencies: Uint16Array;
    /**
     * Create new Huffman Tree
     * @param {CompressedStreamWriter} writer instance
     * @param {number} elementCount - element count
     * @param {number} minCodes - minimum count
     * @param {number} maxLength - maximum count
     */
    constructor(writer: CompressedStreamWriter, elementCount: number, minCodes: number, maxLength: number);
    /**
     * setStaticCodes.
     * @param {Int16Array | number[]} codes - The codes parameter.
     * @param {Uint8Array | number[]} lengths - The lengths parameter.
     * @returns {void} Nothing.
     */
    setStaticCodes(codes: Int16Array | number[], lengths: Uint8Array | number[]): void;
    /**
     * reset all code data in tree
     * @returns {void} The result.
     */
    reset(): void;
    /**
     * write code to the compressor output stream
     * @param {number} code - code to be written
     * @returns {void} The result.
     */
    writeCodeToStream(code: number): void;
    /**
     * calculate code from their frequencies
     * @returns {void} The result.
     */
    buildCodes(): void;
    /**
     * bitReverse.
     * @param {number} value - The value parameter.
     * @returns {number} The result.
     */
    static bitReverse(value: number): number;
    /**
     * calculate length of compressed data
     * @returns {number} The result.
     */
    getEncodedLength(): number;
    /**
     * calculate code frequencies
     * @param {CompressorHuffmanTree} blTree - The blTree parameter.
     * @returns {void} The result.
     */
    calculateBLFreq(blTree: CompressorHuffmanTree): void;
    /**
     * @param {CompressorHuffmanTree} blTree - write tree to output stream
     * @returns {void} The result.
     */
    writeTree(blTree: CompressorHuffmanTree): void;
    /**
     * Build huffman tree
     * @returns {void} The result.
     */
    buildTree(): void;
    /**
     * constructHuffmanTree.
     * @param {Int32Array} arrTree - The arrTree parameter.
     * @param {number} treeLength - The treeLength parameter.
     * @param {Int32Array} values - The values parameter.
     * @param {number} nodesCount - The nodesCount parameter.
     * @param {Int32Array} child - The child parameter.
     * @returns {void} Nothing.
     */
    constructHuffmanTree(arrTree: Int32Array, treeLength: number, values: Int32Array, nodesCount: number, child: Int32Array): void;
    /**
     * buildLength.
     * @param {Int32Array} child - The child parameter.
     * @returns {void} Nothing.
     */
    buildLength(child: Int32Array): void;
    /**
     * recreateTree.
     * @param {Int32Array} child - The child parameter.
     * @param {number} overflow - The overflow parameter.
     * @param {number} numLeafs - The numLeafs parameter.
     * @returns {void} Nothing.
     */
    recreateTree(child: Int32Array, overflow: number, numLeafs: number): void;
    /**
     * calculateOptimalCodeLength.
     * @param {Int32Array} child - The child parameter.
     * @param {number} overflow - The overflow parameter.
     * @param {number} numNodes - The numNodes parameter.
     * @returns {number} The result.
     */
    calculateOptimalCodeLength(child: Int32Array, overflow: number, numNodes: number): number;
}
/**
 * Checksum calculator, based on Adler32 algorithm.
 */
export declare class ChecksumCalculator {
    static checkSumBitOffset: number;
    static checksumBase: number;
    static checksumIterationCount: number;
    /**
     * Updates checksum by calculating checksum of the
     * given buffer and adding it to current value.
     * @param {number} checksum - current checksum.
     * @param {Uint8Array} buffer - data byte array.
     * @param {number} offset - offset in the buffer.
     * @param {number} length - length of data to be used from the stream.
     * @returns {number} The result.
     */
    static checksumUpdate(checksum: number, buffer: Uint8Array, offset: number, length: number): number;
}