@types/yauzl

comment: string;

compressedSize: number;

compressionMethod: number;

crc32: number;

externalFileAttributes: number;

extraFieldLength: number;

extraFieldRaw: Buffer;

extraFields: ExtraField[];

fileComment: string;

fileCommentLength: number;

fileCommentRaw: Buffer;

fileName: string;

fileNameLength: number;

fileNameRaw: Buffer;

generalPurposeBitFlag: number;

internalFileAttributes: number;

lastModFileDate: number;

lastModFileTime: number;

relativeOffsetOfLocalHeader: number;

uncompressedSize: number;

versionMadeBy: number;

versionNeededToExtract: number;

canDecodeFileData: () => boolean;

getLastModDate: (options?: GetLastModDateOptions) => Date;

isCompressed: () => boolean;

isEncrypted: () => boolean;

compressedSize: number;

compressionMethod: number;

crc32: number;

extraField: Buffer;

extraFieldLength: number;

fileDataStart: number;

fileName: Buffer;

fileNameLength: number;

generalPurposeBitFlag: number;

lastModFileDate: number;

lastModFileTime: number;

uncompressedSize: number;

versionNeededToExtract: number;

close: (callback: (err: Error | null) => void) => void;

createReadStream: (options: { start: number; end: number }) => Readable;

read: (
    buffer: Buffer,
    offset: number,
    length: number,
    position: number,
    callback: (err: Error | null) => void
) => void;

constructor(
    reader: RandomAccessReader,
    centralDirectoryOffset: number,
    fileSize: number,
    entryCount: number,
    comment: string,
    autoClose: boolean,
    lazyEntries: boolean,
    decodeStrings: boolean,
    validateEntrySizes: boolean
);

autoClose: boolean;

comment: string;

decodeStrings: boolean;

emittedError: boolean;

entriesRead: number;

entryCount: number;

fileSize: number;

isOpen: boolean;

lazyEntries: boolean;

readEntryCursor: boolean;

validateEntrySizes: boolean;

close: () => void;

eachEntry: () => AsyncIterableIterator<Entry>;

openReadStream: {
    (
        entry: Entry,
        options: ZipFileOptions,
        callback: (err: Error | null, stream: Readable) => void
    ): void;
    (entry: Entry, callback: (err: Error, stream: Readable) => void): void;
};

openReadStreamLowLevel: (
    fileDataStart: number,
    compressedSize: number,
    relativeStart: number,
    relativeEnd: number,
    decompress: boolean,
    uncompressedSize: number | null,
    callback: (err: Error | null, stream: Readable) => void
) => void;

openReadStreamLowLevelPromise: (
    fileDataStart: number,
    compressedSize: number,
    relativeStart: number,
    relativeEnd: number,
    decompress: boolean,
    uncompressedSize: number | null
) => Promise<Readable>;

openReadStreamPromise: (
    entry: Entry,
    options?: ZipFileOptions
) => Promise<Readable>;

readEntry: () => void;

readLocalFileHeader: {
    (
        entry: Entry,
        options: { minimal: true },
        callback: (err: Error | null, header: { fileDataStart: number }) => void
    ): void;
    (
        entry: Entry,
        options: { minimal?: boolean },
        callback: (err: Error, header: LocalFileHeader) => void
    ): void;
    (
        entry: Entry,
        callback: (err: Error, header: LocalFileHeader) => void
    ): void;
};

readLocalFileHeaderPromise: {
    (entry: Entry, options: { minimal: true }): Promise<{
        fileDataStart: number;
    }>;
    (entry: Entry, options?: { minimal?: boolean }): Promise<LocalFileHeader>;
};

data: Buffer;

id: number;

forceDosFormat?: boolean | undefined;

timezone?: 'local' | 'UTC' | null | undefined;

autoClose?: boolean | undefined;

decodeStrings?: boolean | undefined;

lazyEntries?: boolean | undefined;

strictFileNames?: boolean | undefined;

validateEntrySizes?: boolean | undefined;

decodeFileData?: boolean | null | undefined;

decompress?: boolean | null | undefined;

decrypt?: boolean | null | undefined;

end?: number | null | undefined;

start?: number | null | undefined;