• Version 0.10.9
  • Published
  • 6.09 kB
  • 1 dependency
  • MIT license


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


TypeScript definitions for unzipper



function BufferStream

BufferStream: (entry: Entry) => Promise<Buffer>;

    function Extract

    Extract: (opts?: ParseOptions) => ParseStream;

      function Parse

      Parse: (opts?: ParseOptions) => ParseStream;

        function ParseOne

        ParseOne: (match?: RegExp, opts?: ParseOptions) => Duplex;

          function unzip

          unzip: (
          source: { stream: Readable; size: () => Promise<number> },
          offset: number,
          _password: string
          ) => Entry;


            interface CentralDirectory

            interface CentralDirectory {}

              property commentLength

              commentLength: number;

                property diskNumber

                diskNumber: number;

                  property diskStart

                  diskStart: number;

                    property extract

                    extract: (opts: ParseOptions) => Promise<void>;

                      property files

                      files: File[];

                        property numberOfRecords

                        numberOfRecords: number;

                          property numberOfRecordsOnDisk

                          numberOfRecordsOnDisk: number;

                            property offsetToStartOfCentralDirectory

                            offsetToStartOfCentralDirectory: number;

                              property signature

                              signature: number;

                                property sizeOfCentralDirectory

                                sizeOfCentralDirectory: number;

                                  interface Entry

                                  interface Entry extends PassThrough {}

                                    property extra

                                    extra: {
                                    signature: number;
                                    partsize: number;
                                    uncompressedSize: number;
                                    compressedSize: number;
                                    offset: number;
                                    disknum: number;

                                      property path

                                      path: string;

                                        property props

                                        props: {
                                        path: string;

                                          property type

                                          type: string;

                                            property vars

                                            vars: {
                                            signature?: number | undefined;
                                            versionsNeededToExtract: number;
                                            flags: number;
                                            compressionMethod: number;
                                            lastModifiedTime: number;
                                            crc32: number;
                                            compressedSize: number;
                                            fileNameLength: number;
                                            extraFieldLength: number;

                                              method autodrain

                                              autodrain: () => Transform & { promise(): Promise<void> };

                                                method buffer

                                                buffer: () => Promise<Buffer>;

                                                  interface File

                                                  interface File {}

                                                    property buffer

                                                    buffer: (password?: string) => Promise<Buffer>;

                                                      property comment

                                                      comment: string;

                                                        property compressedSize

                                                        compressedSize: number;

                                                          property compressionMethod

                                                          compressionMethod: number;

                                                            property crc32

                                                            crc32: number;

                                                              property diskNumber

                                                              diskNumber: number;

                                                                property externalFileAttributes

                                                                externalFileAttributes: number;

                                                                  property extra

                                                                  extra: any;

                                                                    property extraFieldLength

                                                                    extraFieldLength: number;

                                                                      property fileCommentLength

                                                                      fileCommentLength: number;

                                                                        property fileNameLength

                                                                        fileNameLength: number;

                                                                          property flags

                                                                          flags: number;

                                                                            property internalFileAttributes

                                                                            internalFileAttributes: number;

                                                                              property isUnicode

                                                                              isUnicode: number;

                                                                                property lastModifiedDate

                                                                                lastModifiedDate: number;

                                                                                  property lastModifiedDateTime

                                                                                  lastModifiedDateTime: Date;

                                                                                    property lastModifiedTime

                                                                                    lastModifiedTime: number;

                                                                                      property offsetToLocalFileHeader

                                                                                      offsetToLocalFileHeader: number;

                                                                                        property path

                                                                                        path: string;

                                                                                          property pathBuffer

                                                                                          pathBuffer: Buffer;

                                                                                            property signature

                                                                                            signature: number;

                                                                                              property stream

                                                                                              stream: (password?: string) => Entry;

                                                                                                property type

                                                                                                type: 'Directory' | 'File';

                                                                                                  property uncompressedSize

                                                                                                  uncompressedSize: number;

                                                                                                    property versionMadeBy

                                                                                                    versionMadeBy: number;

                                                                                                      property versionsNeededToExtract

                                                                                                      versionsNeededToExtract: number;

                                                                                                        interface ParseOptions

                                                                                                        interface ParseOptions {}

                                                                                                          property concurrency

                                                                                                          concurrency?: number | undefined;

                                                                                                            property forceStream

                                                                                                            forceStream?: boolean | undefined;

                                                                                                              property path

                                                                                                              path?: string | undefined;

                                                                                                                property verbose

                                                                                                                verbose?: boolean | undefined;

                                                                                                                  interface PullStream

                                                                                                                  interface PullStream extends Duplex {}

                                                                                                                    method pull

                                                                                                                    pull: (eof: number | string, includeEof: boolean) => Promise<Buffer>;

                                                                                                                      method stream

                                                                                                                      stream: (eof: number | string, includeEof: boolean) => PassThrough;

                                                                                                                        Type Aliases

                                                                                                                        type ParseStream

                                                                                                                        type ParseStream = PullStream & {
                                                                                                                        promise(): Promise<void>;


                                                                                                                          namespace Open

                                                                                                                          namespace Open {}

                                                                                                                            function buffer

                                                                                                                            buffer: (data: Buffer) => Promise<CentralDirectory>;

                                                                                                                              function file

                                                                                                                              file: (filename: string) => Promise<CentralDirectory>;

                                                                                                                                function s3

                                                                                                                                s3: (client: any, params: any) => Promise<CentralDirectory>;

                                                                                                                                  function url

                                                                                                                                  url: (
                                                                                                                                  request: ClientRequest,
                                                                                                                                  opt: string | RequestOptions
                                                                                                                                  ) => Promise<CentralDirectory>;

                                                                                                                                    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/unzipper.

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