• Version 2.10.3
  • Published
  • 6.11 kB
  • 1 dependency
  • MIT license


npm i @types/yauzl
yarn add @types/yauzl
pnpm add @types/yauzl


TypeScript definitions for yauzl



function dosDateTimeToDate

dosDateTimeToDate: (date: number, time: number) => Date;

    function fromBuffer

    fromBuffer: {
    buffer: Buffer,
    options: Options,
    callback?: (err: Error | null, zipfile: ZipFile) => void
    ): void;
    (buffer: Buffer, callback?: (err: Error, zipfile: ZipFile) => void): void;

      function fromFd

      fromFd: {
      fd: number,
      options: Options,
      callback?: (err: Error | null, zipfile: ZipFile) => void
      ): void;
      (fd: number, callback?: (err: Error, zipfile: ZipFile) => void): void;

        function fromRandomAccessReader

        fromRandomAccessReader: {
        reader: RandomAccessReader,
        totalSize: number,
        options: Options,
        callback: (err: Error | null, zipfile: ZipFile) => void
        ): void;
        reader: RandomAccessReader,
        totalSize: number,
        callback: (err: Error, zipfile: ZipFile) => void
        ): void;

          function open

          open: {
          path: string,
          options: Options,
          callback?: (err: Error | null, zipfile: ZipFile) => void
          ): void;
          (path: string, callback?: (err: Error, zipfile: ZipFile) => void): void;

            function validateFileName

            validateFileName: (fileName: string) => string | null;


              class Entry

              class Entry {}

                property comment

                comment: string;

                  property compressedSize

                  compressedSize: number;

                    property compressionMethod

                    compressionMethod: number;

                      property crc32

                      crc32: number;

                        property externalFileAttributes

                        externalFileAttributes: number;

                          property extraFieldLength

                          extraFieldLength: number;

                            property extraFields

                            extraFields: { id: number; data: Buffer }[];

                              property fileCommentLength

                              fileCommentLength: number;

                                property fileName

                                fileName: string;

                                  property fileNameLength

                                  fileNameLength: number;

                                    property generalPurposeBitFlag

                                    generalPurposeBitFlag: number;

                                      property internalFileAttributes

                                      internalFileAttributes: number;

                                        property lastModFileDate

                                        lastModFileDate: number;

                                          property lastModFileTime

                                          lastModFileTime: number;

                                            property relativeOffsetOfLocalHeader

                                            relativeOffsetOfLocalHeader: number;

                                              property uncompressedSize

                                              uncompressedSize: number;

                                                property versionMadeBy

                                                versionMadeBy: number;

                                                  property versionNeededToExtract

                                                  versionNeededToExtract: number;

                                                    method getLastModDate

                                                    getLastModDate: () => Date;

                                                      method isCompressed

                                                      isCompressed: () => boolean;

                                                        method isEncrypted

                                                        isEncrypted: () => boolean;

                                                          class RandomAccessReader

                                                          abstract class RandomAccessReader extends EventEmitter {}

                                                            method close

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

                                                              method createReadStream

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

                                                                method read

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

                                                                  class ZipFile

                                                                  class ZipFile extends EventEmitter {}


                                                                    reader: RandomAccessReader,
                                                                    centralDirectoryOffset: number,
                                                                    fileSize: number,
                                                                    entryCount: number,
                                                                    comment: string,
                                                                    autoClose: boolean,
                                                                    lazyEntries: boolean,
                                                                    decodeStrings: boolean,
                                                                    validateEntrySizes: boolean

                                                                      property autoClose

                                                                      autoClose: boolean;

                                                                        property comment

                                                                        comment: string;

                                                                          property decodeStrings

                                                                          decodeStrings: boolean;

                                                                            property emittedError

                                                                            emittedError: boolean;

                                                                              property entriesRead

                                                                              entriesRead: number;

                                                                                property entryCount

                                                                                entryCount: number;

                                                                                  property fileSize

                                                                                  fileSize: number;

                                                                                    property isOpen

                                                                                    isOpen: boolean;

                                                                                      property lazyEntries

                                                                                      lazyEntries: boolean;

                                                                                        property readEntryCursor

                                                                                        readEntryCursor: boolean;

                                                                                          property validateEntrySizes

                                                                                          validateEntrySizes: boolean;

                                                                                            method close

                                                                                            close: () => void;

                                                                                              method openReadStream

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

                                                                                                method readEntry

                                                                                                readEntry: () => void;


                                                                                                  interface Options

                                                                                                  interface Options {}

                                                                                                    property autoClose

                                                                                                    autoClose?: boolean | undefined;

                                                                                                      property decodeStrings

                                                                                                      decodeStrings?: boolean | undefined;

                                                                                                        property lazyEntries

                                                                                                        lazyEntries?: boolean | undefined;

                                                                                                          property strictFileNames

                                                                                                          strictFileNames?: boolean | undefined;

                                                                                                            property validateEntrySizes

                                                                                                            validateEntrySizes?: boolean | undefined;

                                                                                                              interface ZipFileOptions

                                                                                                              interface ZipFileOptions {}

                                                                                                                property decompress

                                                                                                                decompress: boolean | null;

                                                                                                                  property decrypt

                                                                                                                  decrypt: boolean | null;

                                                                                                                    property end

                                                                                                                    end: number | null;

                                                                                                                      property start

                                                                                                                      start: number | null;

                                                                                                                        Package Files (1)

                                                                                                                        Dependencies (1)

                                                                                                                        Dev Dependencies (0)

                                                                                                                        No dev dependencies.

                                                                                                                        Peer Dependencies (0)

                                                                                                                        No peer dependencies.


                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/yauzl.

                                                                                                                        • Markdown
                                                                                                                        • HTML
                                                                                                                          <a href="https://www.jsdocs.io/package/@types/yauzl"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>