@types/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;

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

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

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

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<T extends string = string> = {
    readonly [Prop in T]?: string[];
};

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

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

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

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

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