• Version 2.0.5
  • Published
  • 18.3 kB
  • 1 dependency
  • MIT license


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


TypeScript definitions for formidable



variable formidable

const formidable: {
(options?: formidable.Options): Formidable;
defaultOptions: formidable.DefaultOptions;
enabledPlugins: formidable.EnabledPlugins;
plugins: formidable.EnabledPlugins;
errors: typeof errors;
File: typeof PersistentFile;
PersistentFile: typeof PersistentFile;
VolatileFile: typeof VolatileFile;
Formidable: typeof Formidable;
formidable: (options?: formidable.Options) => Formidable;
IncomingForm: typeof Formidable;
parsers: typeof parsers;
} & formidable.MappedParsers;


    interface EmitData

    interface EmitData {}

      property formname

      formname: any;

        property key

        key?: string | number | undefined;

          property name

          name: 'fileBegin' | 'file';

            property value

            value: File | string;

              interface EventData

              interface EventData {}

                property buffer

                buffer: string;

                  property end

                  end: string;

                    property formname

                    formname: string;

                      property key

                      key: string;

                        property name

                        name: EventNames;

                          property start

                          start: string;

                            property value

                            value: string;

                              interface Fields

                              interface Fields {}

                                index signature

                                [field: string]: string | string[];

                                  interface File

                                  interface File {}

                                    property filepath

                                    filepath: string;
                                    • The path this file is being written to. You can modify this in the 'fileBegin' event in case you are unhappy with the way formidable generates a temporary path for your files.

                                    property hash

                                    hash?: string | null;
                                    • If options.hashAlgorithm calculation was set, you can read the hex digest out of this var (at the end it will be a string).

                                    property hashAlgorithm

                                    hashAlgorithm: false | 'sha1' | 'md5' | 'sha256';

                                      property mimetype

                                      mimetype: string | null;
                                      • The mime type of this file, according to the uploading client.

                                      property mtime

                                      mtime?: Date | null | undefined;
                                      • A Date object (or null) containing the time this file was last written to. Mostly here for compatibility with the [W3C File API Draft](http://dev.w3.org/2006/webapi/FileAPI/).

                                      property newFilename

                                      newFilename: string;
                                      • Calculated based on options provided

                                      property originalFilename

                                      originalFilename: string | null;
                                      • The name this file had according to the uploading client.

                                      property size

                                      size: number;
                                      • The size of the uploaded file in bytes. If the file is still being uploaded (see 'fileBegin' event), this property says how many bytes of the file have been written to disk yet.

                                      method toJSON

                                      toJSON: () => FileJSON;
                                      • This method returns a JSON-representation of the file, allowing you to JSON.stringify() the file which is useful for logging and responding to requests.


                                      method toString

                                      toString: () => string;

                                        interface FileJSON

                                        interface FileJSON
                                        extends Pick<
                                        'size' | 'filepath' | 'originalFilename' | 'mimetype' | 'hash'
                                        > {}
                                        • https://github.com/node-formidable/formidable#file

                                        property length

                                        length: number;

                                          property mimetype

                                          mimetype: string | null;

                                            property mtime

                                            mtime: Date | null;

                                              interface Files

                                              interface Files {}

                                                index signature

                                                [file: string]: File | File[];

                                                  interface Options

                                                  interface Options {}

                                                    property allowEmptyFiles

                                                    allowEmptyFiles?: boolean | undefined;
                                                    • allow upload empty files


                                                    property enabledPlugins

                                                    enabledPlugins?: string[] | undefined;

                                                      property encoding

                                                      encoding?: BufferEncoding | undefined;
                                                      • sets encoding for incoming form fields


                                                      property filename

                                                      filename?: (name: string, ext: string, part: Part, form: Formidable) => string;
                                                      • Use it to control newFilename. Must return a string. Will be joined with options.uploadDir.


                                                      property fileWriteStreamHandler

                                                      fileWriteStreamHandler?: (() => Writable) | undefined;
                                                      • which by default writes to host machine file system every file parsed; The function should return an instance of a Writable stream that will receive the uploaded file data. With this option, you can have any custom behavior regarding where the uploaded file data will be streamed for. If you are looking to write the file uploaded in other types of cloud storages (AWS S3, Azure blob storage, Google cloud storage) or private file storage, this is the option you're looking for. When this option is defined the default behavior of writing the file in the host machine file system is lost.


                                                      property filter

                                                      filter?: (part: Part) => boolean;

                                                        property hashAlgorithm

                                                        hashAlgorithm?: string | false | undefined;
                                                        • include checksums calculated for incoming files, set this to some hash algorithm, see crypto.createHash for available algorithms


                                                        property keepExtensions

                                                        keepExtensions?: boolean | undefined;
                                                        • to include the extensions of the original files or not


                                                        property maxFields

                                                        maxFields?: number | undefined;
                                                        • limit the number of fields, set 0 for unlimited


                                                        property maxFieldsSize

                                                        maxFieldsSize?: number | undefined;
                                                        • limit the amount of memory all fields together (except files) can allocate in bytes

                                                          20 * 1024 * 1024

                                                        property maxFiles

                                                        maxFiles?: number | undefined;
                                                        • limit the amount of uploaded files, set Infinity for unlimited


                                                        property maxFileSize

                                                        maxFileSize?: number | undefined;
                                                        • limit the size of uploaded file

                                                          200 * 1024 * 1024

                                                        property maxTotalFileSize

                                                        maxTotalFileSize?: number | undefined;
                                                        • limit the size of the batch of uploaded files


                                                        property minFileSize

                                                        minFileSize?: number | undefined;
                                                        • the minium size of uploaded file


                                                        property multiples

                                                        multiples?: boolean | undefined;
                                                        • when you call the .parse method, the files argument (of the callback) will contain arrays of files for inputs which submit multiple files using the HTML5 multiple attribute. Also, the fields argument will contain arrays of values for fields that have names ending with '[]'


                                                        property uploadDir

                                                        uploadDir?: string | undefined;
                                                        • the directory for placing file uploads in. You can move them later by using fs.rename()


                                                        interface Part

                                                        interface Part extends Stream {}

                                                          property mimetype

                                                          mimetype: string | null;

                                                            property name

                                                            name: string | null;

                                                              property originalFilename

                                                              originalFilename: string | null;

                                                                Type Aliases

                                                                type BufferEncoding

                                                                type BufferEncoding =
                                                                | 'ascii'
                                                                | 'base64'
                                                                | 'binary'
                                                                | 'hex'
                                                                | 'latin1'
                                                                | 'ucs-2'
                                                                | 'ucs2'
                                                                | 'utf-8'
                                                                | 'utf16le'
                                                                | 'utf8';

                                                                  type DefaultOptions

                                                                  type DefaultOptions = Required<Omit<Options, 'enabledPlugins'>> & {
                                                                  enabledPlugins: EnabledPlugins;

                                                                    type EnabledPlugins

                                                                    type EnabledPlugins = {
                                                                    [P in Plugin]: PluginFunction;

                                                                      type EventNames

                                                                      type EventNames =
                                                                      * Emitted when the request was aborted by the user. Right now this can be due to a 'timeout' or
                                                                      * 'close' event on the socket. After this event is emitted, an error event will follow. In the
                                                                      * future there will be a separate 'timeout' event (needs a change in the node core).
                                                                      * @link https://github.com/node-formidable/formidable#aborted
                                                                      | 'aborted'
                                                                      * Emitted when the entire request has been received, and all contained files have finished
                                                                      * flushing to disk. This is a great place for you to send your response.
                                                                      * @link https://github.com/node-formidable/formidable#end
                                                                      | 'end'
                                                                      * Emitted when there is an error processing the incoming form. A request that experiences an
                                                                      * error is automatically paused, you will have to manually call request.resume() if you want the
                                                                      * request to continue firing 'data' events.
                                                                      * @link https://github.com/node-formidable/formidable#error
                                                                      | 'error'
                                                                      * Emitted whenever a field / value pair has been received.
                                                                      * @link https://github.com/node-formidable/formidable#field
                                                                      | 'field'
                                                                      * Emitted whenever a field / file pair has been received. file is an instance of File.
                                                                      * @link https://github.com/node-formidable/formidable#file-1
                                                                      | 'file'
                                                                      * Emitted whenever a new file is detected in the upload stream. Use this event if you want to
                                                                      * stream the file to somewhere else while buffering the upload on the file system.
                                                                      * @link https://github.com/node-formidable/formidable#filebegin
                                                                      | 'fileBegin'
                                                                      | 'headerEnd'
                                                                      | 'headerField'
                                                                      | 'headersEnd'
                                                                      | 'headerValue'
                                                                      | 'partBegin'
                                                                      | 'partData'
                                                                      * Emitted after each incoming chunk of data that has been parsed. Can be used to roll your own
                                                                      * progress bar.
                                                                      * @link https://github.com/node-formidable/formidable#progress
                                                                      | 'progress';

                                                                        type MappedParsers

                                                                        type MappedParsers = {
                                                                        [P in keyof typeof parsers]: typeof parsers[P];

                                                                          type Plugin

                                                                          type Plugin = keyof { [K in Plugins[number]]: K };

                                                                            type PluginFunction

                                                                            type PluginFunction = (formidable: Formidable, options: Partial<Options>) => void;

                                                                              type Plugins

                                                                              type Plugins = ['octetstream', 'querystring', 'multipart', 'json'];

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

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