Logo for jsDocs.io

@types/yauzl

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

Install

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

Overview

TypeScript definitions for yauzl

Index

Functions

Classes

Interfaces

Functions

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;

              Classes

              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 {}

                                                                    constructor

                                                                    constructor(
                                                                        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;

                                                                                                  Interfaces

                                                                                                  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.

                                                                                                                        Badge

                                                                                                                        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
                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/yauzl)
                                                                                                                        • 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>