• Version 3.4.5
  • Published
  • 19 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 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'
                                    | 'newFilename'
                                    > {}
                                    • https://github.com/node-formidable/formidable#file

                                    property length

                                    length: number;

                                      property mimetype

                                      mimetype: string | null;

                                        property mtime

                                        mtime: Date | null;

                                          interface Options

                                          interface Options {}

                                            property allowEmptyFiles

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


                                            property createDirsFromUploads

                                            createDirsFromUploads?: boolean | undefined;
                                            • If true, makes direct folder uploads possible.


                                            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?: ((file?: VolatileFile) => 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 Fields

                                                                type Fields<T extends string = string> = {
                                                                readonly [Prop in T]?: string[];

                                                                  type Files

                                                                  type Files<U extends string = string> = {
                                                                  readonly [Prop in U]?: File[];

                                                                    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>