import { PdfToken } from '../tokens/token.js';
import { PdfDictionary } from './pdf-dictionary.js';
import { PdfObject } from './pdf-object.js';
import { ByteArray, DecodeParms } from '../../types.js';
import { PdfNumber } from './pdf-number.js';
import { PdfIndirectObject } from './pdf-indirect-object.js';
import { PdfXRefTableEntry } from './pdf-xref-table.js';
import { PdfFilter, PdfStreamFilterType } from '../../filters/types.js';
export declare class PdfStreamPredictor extends PdfDictionary<{
    Predictor?: PdfNumber;
    Columns?: PdfNumber;
    Colors?: PdfNumber;
    BitsPerComponent?: PdfNumber;
}> {
    static NONE: PdfStreamPredictor;
    static TIFF: PdfStreamPredictor;
    static PNG_NONE: PdfStreamPredictor;
    static PNG_SUB: PdfStreamPredictor;
    static PNG_UP: PdfStreamPredictor;
    static PNG_AVERAGE: PdfStreamPredictor;
    static PNG_PAETH: PdfStreamPredictor;
    static PNG_OPTIMUM: PdfStreamPredictor;
    static XREF_STREAM: PdfStreamPredictor;
    get predictor(): number;
    set predictor(value: number);
    get columns(): number;
    set columns(value: number);
    get colors(): number;
    set colors(value: number);
    get bitsPerComponent(): number;
    set bitsPerComponent(value: number);
    toDecodeParms(): DecodeParms;
    cloneImpl(): this;
    static fromDecodeParms(params: DecodeParms): PdfStreamPredictor;
    static fromDictionary(dict?: PdfDictionary): PdfStreamPredictor | undefined;
    encode(data: ByteArray, filterType?: number): ByteArray;
    decode(data: ByteArray): ByteArray;
    private static tiffDecode;
    private static tiffEncode;
    private static pngDecode;
    private static pngEncode;
    private static paethPredictor;
}
export declare class PdfStream<T extends PdfDictionary = PdfDictionary> extends PdfObject {
    static PdfStreamPredictor: typeof PdfStreamPredictor;
    header: T;
    original: ByteArray;
    preStreamDataTokens?: PdfToken[];
    postStreamDataTokens?: PdfToken[];
    constructor(options: {
        header: T;
        original: ByteArray | string;
        isModified?: boolean;
    } | ByteArray | string);
    get raw(): ByteArray;
    set raw(data: ByteArray);
    get originalAsString(): string;
    get rawAsString(): string;
    set rawAsString(str: string);
    get data(): ByteArray;
    set data(data: ByteArray);
    get dataAsString(): string;
    set dataAsString(str: string);
    getFilters(): PdfStreamFilterType[];
    addFilter(filterName: PdfStreamFilterType): this;
    get predictor(): PdfStreamPredictor | undefined;
    set predictor(predictor: PdfStreamPredictor);
    removeFilter(filterName: PdfStreamFilterType): this;
    removePredictor(): this;
    removeAllFilters(): this;
    decode(): ByteArray;
    parseAs<T extends PdfStream>(Class: new (options: {
        header: PdfDictionary;
        original: ByteArray;
        isModified?: boolean;
    }) => T): T;
    protected tokenize(): PdfToken[];
    toJSON(): {
        type: string;
        header: {
            type: string;
            entries: Record<string, object>;
        };
        dataLength: number;
    };
    isType(name: string): boolean;
    static getFilter(name: PdfStreamFilterType): PdfFilter;
    static getAllFilters(): {
        readonly FlateDecode: PdfFilter;
        readonly Fl: PdfFilter;
        readonly ASCIIHexDecode: PdfFilter;
        readonly ASCII85Decode: PdfFilter;
        readonly LZWDecode: PdfFilter;
        readonly RunLengthDecode: PdfFilter;
        readonly CCITTFaxDecode: PdfFilter;
        readonly DCTDecode: PdfFilter;
        readonly JPXDecode: PdfFilter;
        readonly Crypt: PdfFilter;
    };
    static applyFilters(data: ByteArray, filters: PdfStreamFilterType[]): ByteArray;
    cloneImpl(): this;
    static fromString(data: string): PdfStream;
}
export declare class PdfObjStream extends PdfStream {
    private _parsedObjects?;
    set raw(data: ByteArray);
    get raw(): ByteArray;
    constructor(options: {
        header: PdfDictionary;
        original: ByteArray | string;
        isModified?: boolean;
    });
    static fromObjects(objects: Iterable<PdfIndirectObject>): PdfObjStream;
    getObjectStream(): Generator<PdfIndirectObject>;
    private getParsedObjects;
    getObject(options: {
        objectNumber: number;
    }): PdfIndirectObject | undefined;
    getObjects(): PdfIndirectObject[];
    cloneImpl(): this;
}
export declare class PdfXRefStreamCompressedEntry {
    objectNumber: PdfNumber;
    objectStreamNumber: PdfNumber;
    index: PdfNumber;
    constructor(options: {
        objectNumber: number | PdfNumber;
        objectStreamNumber: number | PdfNumber;
        index: number | PdfNumber;
    });
}
export type PdfXRefStreamStandardEntry = PdfXRefTableEntry;
export declare const PdfXRefStreamStandardEntry: typeof PdfXRefTableEntry;
export type PdfXRefStreamEntry = PdfXRefStreamStandardEntry | PdfXRefStreamCompressedEntry;
export declare class PdfXRefStream extends PdfStream {
    constructor(options?: {
        header?: PdfDictionary;
        original?: ByteArray | string;
        isModified?: boolean;
    });
    static createNewHeader(): PdfDictionary;
    static fromEntries(entries: PdfXRefStreamEntry[], headerDict?: PdfDictionary): PdfXRefStream;
    addEntry(entry: PdfXRefStreamEntry): this;
    private static calculateW;
    get prev(): PdfNumber | undefined;
    getEntryStream(): Generator<PdfXRefStreamEntry>;
    getEntries(): PdfXRefStreamEntry[];
    private readInt;
    cloneImpl(): this;
}