react-dropzone

const Dropzone: React.ForwardRefExoticComponent<any>;

useDropzone: (props?: DropzoneOptions) => DropzoneState;

type DragFileRejection = DragFileRejection$1<FileWithPath | DataTransferItem>;

type DropEvent =
    | React.DragEvent<HTMLElement>
    | React.ChangeEvent<HTMLInputElement>
    | React.ClipboardEvent<HTMLElement>
    | DragEvent
    | ClipboardEvent
    | Event;

type DropzoneOptions = Pick<React.HTMLProps<HTMLElement>, SharedProps> & {
    accept?: Accept | AcceptGroup[];
    minSize?: number;
    maxSize?: number;
    maxFiles?: number;
    preventDropOnDocument?: boolean;
    noClick?: boolean;
    noKeyboard?: boolean;
    noDrag?: boolean;
    noDragEventsBubbling?: boolean;
    /**
     * If true, disables paste-to-upload. By default, when the dropzone (or a focused child) receives a
     * paste that carries files - e.g. a screenshot pasted with Ctrl/Cmd+V - those files go through the
     * same `accept`/size/`validator` checks and `onDrop` callbacks as a drop. Pastes with no files
     * (plain text, etc.) are ignored and left untouched. See
     * https://github.com/react-dropzone/react-dropzone/issues/1210
     */
    noPaste?: boolean;
    disabled?: boolean;
    onDrop?: <T extends File>(
        acceptedFiles: T[],
        fileRejections: FileRejection[],
        event: DropEvent
    ) => void;
    onDropAccepted?: <T extends File>(files: T[], event: DropEvent) => void;
    onDropRejected?: (fileRejections: FileRejection[], event: DropEvent) => void;
    getFilesFromEvent?: (
        event: DropEvent | Array<FileSystemFileHandle>
    ) => Promise<Array<File | DataTransferItem>>;
    onFileDialogCancel?: () => void;
    onFileDialogOpen?: () => void;
    onError?: (err: Error) => void;
    /**
     * Custom validation, run once per file on drop/selection. Return `null` to accept the file, or a
     * {@link FileError} (or array of them) to reject it. May be `async` (return a `Promise`) to support
     * checks that can't run synchronously - e.g. reading image dimensions, inspecting file contents,
     * or calling an external service. While an async validator is pending, {@link DropzoneState.isProcessing}
     * is `true`, and `onDrop`/`onDropAccepted`/`onDropRejected` fire only once it settles. If the
     * validator throws or rejects, `onError` is called and the drop is discarded.
     *
     * Note: the validator never runs during a drag (a `DataTransferItem` has no name/size), so a
     * validator-configured dropzone is `isDragUnknown` until drop.
     */
    validator?: <T extends File>(
        file: T
    ) => ValidatorResult | Promise<ValidatorResult>;
    /**
     * Override the message of any rejection error (built-in or custom). Called once per error;
     * receives the error and the file it belongs to and returns the message to use. Return
     * `error.message` for codes you don't want to change. Useful for localizing error messages.
     */
    getErrorMessage?: (error: FileError, file: File) => string;
    useFsAccessApi?: boolean;
    autoFocus?: boolean;
};

type DropzoneState = DropzoneRef & {
    isFocused: boolean;
    isDragActive: boolean;
    isDragAccept: boolean;
    isDragReject: boolean;
    isDragUnknown: boolean;
    isDragGlobal: boolean;
    isFileDialogActive: boolean;
    /**
     * `true` while a drop/selection is being processed asynchronously - i.e. while `getFilesFromEvent`
     * reads the files and/or an async {@link DropzoneOptions.validator} runs. Spans the whole pipeline,
     * from when files start being read until validation settles. When both are synchronous (the default
     * `getFilesFromEvent` with no/async-free validator) the work resolves within a microtask, so it's
     * only observable for genuinely async work. Use it to show a spinner or disable UI while processing.
     */
    isProcessing: boolean;
    acceptedFiles: readonly FileWithPath[];
    fileRejections: readonly FileRejection[];
    /**
     * Rejections that can be determined before drop. Standard drag events expose
     * `DataTransferItem`s with a MIME type but no name or size, so extension, size, and custom
     * validator failures are only available in {@link fileRejections} after drop. In practice this
     * state can report MIME-type and surplus-file errors during a standard browser drag.
     */
    dragFileRejections: readonly DragFileRejection[];
    rootRef: React.RefObject<HTMLElement>;
    inputRef: React.RefObject<HTMLInputElement>;
    getRootProps: <T extends DropzoneRootProps>(props?: T) => T;
    getInputProps: <T extends DropzoneInputProps>(props?: T) => T;
};

type ValidatorResult = FileError | readonly FileError[] | null;