/**
 * @license
 *-------------------------------------------------------------------------------------------
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the package root for more information
 *-------------------------------------------------------------------------------------------
 */
import { AxiosProgressEvent } from 'axios';
import { AxiosResponse } from 'axios';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import { LocalizationService } from '@progress/kendo-vue-intl';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { SVGIcon } from '@progress/kendo-svg-icons';
import { UploadActionsLayout as UploadActionsLayout_2 } from '.';
import { UploadAsyncProps as UploadAsyncProps_2 } from '.';
import { UploadFileRestrictions as UploadFileRestrictions_2 } from '.';
import { UploadHttpHeaders as UploadHttpHeaders_2 } from '.';

/**
 * @hidden
 */
declare interface BaseUploadEvent<T> {
    /**
     * An event target.
     */
    target: T;
}

/**
 * @hidden
 */
export declare const ExternalDropZone: DefineComponent<ExtractPropTypes<    {
id: PropType<string>;
tabIndex: PropType<number>;
innerStyle: PropType<object>;
uploadRef: PropType<any>;
disabled: PropType<boolean>;
customHint: PropType<any>;
customNote: PropType<any>;
}>, {
externalDropZoneRef: Ref<any, any>;
kendoLocalizationService: {};
}, {
overDropZone: boolean;
}, {}, {
focus(): void;
isDragOver(prevDate: Date | null): boolean;
handleOnDrop(event: any): void;
handleOnElementDragEnter(): void;
handleOnElementDragOver(event: any): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: PropType<string>;
tabIndex: PropType<number>;
innerStyle: PropType<object>;
uploadRef: PropType<any>;
disabled: PropType<boolean>;
customHint: PropType<any>;
customNote: PropType<any>;
}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * @hidden
 */
declare interface GroupedFiles {
    [uid: string]: Array<UploadFileInfo>;
}

/**
 * @hidden
 */
export declare const messages: {
    "upload.cancel": string;
    "upload.clearSelectedFiles": string;
    "upload.dropFileHere": string;
    "upload.dropFilesHere": string;
    "upload.headerStatusUploaded": string;
    "upload.headerStatusUploading": string;
    "upload.invalidFileExtension": string;
    "upload.invalidFiles": string;
    "upload.invalidMaxFileSize": string;
    "upload.invalidMinFileSize": string;
    "upload.remove": string;
    "upload.retry": string;
    "upload.select": string;
    "upload.selectSingle": string;
    "upload.selectTitle": string;
    "upload.selectNoFilesTitle": string;
    "upload.uploadSelectedFiles": string;
    "upload.total": string;
    "upload.files": string;
    "upload.statusUploaded": string;
    "upload.statusUploadFailed": string;
    "upload.dropZoneHint": string;
    "upload.dropZoneNote": string;
};

/**
 * @hidden
 */
export declare const Upload: DefineComponent<ExtractPropTypes<    {
autoUpload: {
type: PropType<boolean>;
default: boolean;
};
batch: {
type: PropType<boolean>;
default: boolean;
};
withCredentials: {
type: PropType<boolean>;
default: boolean;
};
saveField: {
type: PropType<string>;
default: () => "files";
};
saveHeaders: {
type: PropType<UploadHttpHeaders_2>;
default: () => {};
};
saveMethod: {
type: PropType<string>;
default: () => "POST";
};
saveUrl: {
type: PropType<string | ((files: UploadFileInfo[], options: {
formData: FormData;
requestOptions: any;
}, onProgress: (uid: string, event: ProgressEvent<EventTarget>) => void) => Promise<{
uid: string;
}>)>;
default: () => "";
};
responseType: {
type: PropType<"text" | "arraybuffer" | "blob" | "json">;
default: () => "json";
};
removeField: {
type: PropType<string>;
default: () => "fileNames";
};
removeHeaders: {
type: PropType<UploadHttpHeaders_2>;
default: () => {};
};
removeMethod: {
type: PropType<string>;
default: () => "POST";
};
removeUrl: {
type: PropType<string | ((files: UploadFileInfo[], options: {
formData: FormData;
requestOptions: any;
}) => Promise<{
uid: string;
}>)>;
default: () => "";
};
multiple: {
type: PropType<boolean>;
default: boolean;
};
disabled: {
type: PropType<boolean>;
default: boolean;
};
showFileList: {
type: PropType<boolean>;
default: boolean;
};
showActionButtons: {
type: PropType<boolean>;
default: boolean;
};
actionsLayout: {
type: PropType<UploadActionsLayout_2>;
default: () => "end";
};
tabIndex: PropType<string | number>;
accept: PropType<string>;
list: PropType<any>;
restrictions: {
type: PropType<UploadFileRestrictions_2>;
default: () => {
allowedExtensions: any[];
maxFileSize: number;
minFileSize: number;
};
};
validateFile: PropType<(file: UploadFileInfo) => void>;
files: PropType<UploadFileInfo[]>;
defaultFiles: PropType<UploadFileInfo[]>;
}>, {}, {
currentFiles: any[];
}, {
computedAsync(): {
autoUpload: any;
batch: any;
removeField: any;
removeHeaders: any;
removeMethod: any;
removeUrl: any;
responseType: any;
saveField: any;
saveHeaders: any;
saveMethod: any;
saveUrl: any;
withCredentials: any;
};
computedFiles(): Array<UploadFileInfo>;
isControlled(): boolean;
isCustomSave(): boolean;
isCustomRemove(): boolean;
fileStateCopy(): {
uid: string;
name: string;
extension?: string;
size?: number;
validationErrors?: string[];
status: UploadFileStatus;
progress: number;
getRawFile?: () => File;
}[];
actionElement(): any;
}, {
focus(): void;
uploadFiles(filesForUpload: GroupedFiles): void;
removeFiles(filesForRemove: GroupedFiles): void;
onUpload(): void;
onAdd(files: FileList): void;
onUploadProgress(uid: string, event: ProgressEvent | AxiosProgressEvent): void;
onUploadSuccess(uid: string, event?: AxiosResponse): void;
onUploadError(uid: string, event?: AxiosResponse): void;
onRemove(uid: string): void;
onRemoveSuccess(uid: string, event?: AxiosResponse): void;
onRemoveError(uid: string, event?: AxiosResponse): void;
onRetry(uid: string): void;
onCancel(uid: string): void;
onClear(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
add: any;
beforeremove: any;
beforeupload: any;
cancel: any;
statuschange: any;
progress: any;
remove: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
autoUpload: {
type: PropType<boolean>;
default: boolean;
};
batch: {
type: PropType<boolean>;
default: boolean;
};
withCredentials: {
type: PropType<boolean>;
default: boolean;
};
saveField: {
type: PropType<string>;
default: () => "files";
};
saveHeaders: {
type: PropType<UploadHttpHeaders_2>;
default: () => {};
};
saveMethod: {
type: PropType<string>;
default: () => "POST";
};
saveUrl: {
type: PropType<string | ((files: UploadFileInfo[], options: {
formData: FormData;
requestOptions: any;
}, onProgress: (uid: string, event: ProgressEvent<EventTarget>) => void) => Promise<{
uid: string;
}>)>;
default: () => "";
};
responseType: {
type: PropType<"text" | "arraybuffer" | "blob" | "json">;
default: () => "json";
};
removeField: {
type: PropType<string>;
default: () => "fileNames";
};
removeHeaders: {
type: PropType<UploadHttpHeaders_2>;
default: () => {};
};
removeMethod: {
type: PropType<string>;
default: () => "POST";
};
removeUrl: {
type: PropType<string | ((files: UploadFileInfo[], options: {
formData: FormData;
requestOptions: any;
}) => Promise<{
uid: string;
}>)>;
default: () => "";
};
multiple: {
type: PropType<boolean>;
default: boolean;
};
disabled: {
type: PropType<boolean>;
default: boolean;
};
showFileList: {
type: PropType<boolean>;
default: boolean;
};
showActionButtons: {
type: PropType<boolean>;
default: boolean;
};
actionsLayout: {
type: PropType<UploadActionsLayout_2>;
default: () => "end";
};
tabIndex: PropType<string | number>;
accept: PropType<string>;
list: PropType<any>;
restrictions: {
type: PropType<UploadFileRestrictions_2>;
default: () => {
allowedExtensions: any[];
maxFileSize: number;
minFileSize: number;
};
};
validateFile: PropType<(file: UploadFileInfo) => void>;
files: PropType<UploadFileInfo[]>;
defaultFiles: PropType<UploadFileInfo[]>;
}>> & Readonly<{
onProgress?: (...args: any[] | unknown[]) => any;
onCancel?: (...args: any[] | unknown[]) => any;
onAdd?: (...args: any[] | unknown[]) => any;
onRemove?: (...args: any[] | unknown[]) => any;
onBeforeremove?: (...args: any[] | unknown[]) => any;
onBeforeupload?: (...args: any[] | unknown[]) => any;
onStatuschange?: (...args: any[] | unknown[]) => any;
}>, {
disabled: boolean;
multiple: boolean;
autoUpload: boolean;
batch: boolean;
withCredentials: boolean;
saveField: string;
saveHeaders: UploadHttpHeaders_2;
saveMethod: string;
saveUrl: string | ((files: UploadFileInfo[], options: {
formData: FormData;
requestOptions: any;
}, onProgress: (uid: string, event: ProgressEvent<EventTarget>) => void) => Promise<{
uid: string;
}>);
responseType: "text" | "arraybuffer" | "blob" | "json";
removeField: string;
removeHeaders: UploadHttpHeaders_2;
removeMethod: string;
removeUrl: string | ((files: UploadFileInfo[], options: {
formData: FormData;
requestOptions: any;
}) => Promise<{
uid: string;
}>);
actionsLayout: UploadActionsLayout_2;
showFileList: boolean;
showActionButtons: boolean;
restrictions: UploadFileRestrictions_2;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Lists the possible layout of the Upload action buttons.
 */
export declare type UploadActionsLayout = 'start' | 'center' | 'end' | 'stretched';

/**
 * Represents the additional data that is sent as a key-value pair.
 */
export declare interface UploadAdditionalData {
    [name: string]: any;
}

/**
 * Represents the async properties of the Upload component.
 */
export declare interface UploadAsyncProps {
    /**
     * By default, the selected files are immediately uploaded.
     * To change this behavior, set `autoUpload` to `false`.
     */
    autoUpload?: boolean;
    /**
     * When enabled, all files in the selection are uploaded in one request.
     * Any files that are selected one after the other are uploaded in separate requests.
     */
    batch?: boolean;
    /**
     * Configures whether credentials (cookies, headers) will be sent for cross-site requests.
     * Defaults to `true`. Setting `withCredentials` has no effect on same-site requests.
     * To add credentials to the request, use the `saveHeaders` or `removeHeaders` property.
     */
    withCredentials?: boolean;
    /**
     * Sets the [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) key which
     * contains the files submitted to `saveUrl`. Defaults to `files`.
     */
    saveField?: string;
    /**
     * Configures the `HttpHeaders` that are attached to each upload request.
     */
    saveHeaders?: UploadHttpHeaders;
    /**
     * Sets the [`request`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) method of the upload request.
     * Defaults to `POST`.
     */
    saveMethod?: string;
    /**
     * Sets the URL of the endpoint for the upload request.
     * The requested [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) key is named after
     * the `saveField` property and contains the list of files that will be uploaded.
     */
    saveUrl?: string | ((files: UploadFileInfo[], options: {
        formData: FormData;
        requestOptions: any;
    }, onProgress: (uid: string, event: ProgressEvent) => void) => Promise<{
        uid: string;
    }>);
    /**
     * Sets the expected [response type](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType)
     * of the server.
     * Used to parse the response appropriately.
     * Defaults to `json`.
     */
    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
    /**
     * Sets the [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) key
     * which contains the list of file names that are submitted to `removeUrl`.
     * Defaults to `fileNames`.
     */
    removeField?: string;
    /**
     * Configures the `HttpHeaders` that are attached to each `remove` request.
     */
    removeHeaders?: UploadHttpHeaders;
    /**
     * Sets the [request method](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) of the `remove` request.
     * Defaults to `POST`.
     */
    removeMethod?: string;
    /**
     * Sets the URL of the endpoint for the `remove` request.
     * The [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) request
     * key is named after the `removeField` property.
     * It contains the list of file names which will be removed.
     */
    removeUrl?: string | ((files: UploadFileInfo[], options: {
        formData: FormData;
        requestOptions: any;
    }) => Promise<{
        uid: string;
    }>);
}

/**
 * Contains information which is related to the selected file.
 */
export declare interface UploadFileInfo {
    /**
     * The unique identifier of the group (batch) with one or more files.
     * Has to be set for the initial list of files.
     */
    uid: string;
    /**
     * The file name.
     */
    name: string;
    /**
     * The file extension including the leading dot&mdash;for example, `.jpg`, `.png`, or other.
     */
    extension?: string;
    /**
     * The file size in bytes.
     */
    size?: number;
    /**
     * A list which contains the validation errors (if any).
     */
    validationErrors?: Array<string>;
    /**
     * The current state of the file&mdash;`Failed`, `Selected`, `Uploaded`, or `Uploading`.
     * `Initial` is a special value for `FileState` and is
     * automatically applied to initial files without you having to explicitly set their state.
     */
    status: UploadFileStatus;
    /**
     * The current upload progress.
     */
    progress: number;
    /**
     * Gets the raw file instance.
     */
    getRawFile?: () => File;
}

/**
 * Configures the restrictions for the files that can be uploaded.
 */
export declare interface UploadFileRestrictions {
    /**
     * The list of the allowed file extensions.
     * Recognizes entries of both `.type` (for example, `.docx`, `.png`, `.svg`, `.xls`, and others)
     * and `type` (for example, `docx`, `png`, `svg`, `xls`, and others) values.
     */
    allowedExtensions?: Array<string>;
    /**
     * Defines the maximum file size in bytes.
     */
    maxFileSize?: number;
    /**
     * Defines the minimum file size in bytes.
     */
    minFileSize?: number;
}

/**
 * Lists the possible states of a file.
 */
export declare enum UploadFileStatus {
    /**
     * Indicates that the file upload process has failed.
     */
    UploadFailed = 0,
    /**
     * An initially selected fake file without a set state.
     */
    Initial = 1,
    /**
     * The file is selected.
     */
    Selected = 2,
    /**
     * The file is in the process of uploading.
     */
    Uploading = 3,
    /**
     * The file is successfully uploaded.
     */
    Uploaded = 4,
    /**
     * The remove process has failed.
     */
    RemoveFailed = 5,
    /**
     * The file is in the process of removing.
     */
    Removing = 6
}

/**
 * Represents the HttpHeaders as a key-value pair.
 */
export declare interface UploadHttpHeaders {
    [name: string]: string | string[];
}

/**
 * @hidden
 */
export declare const UploadListActionButton: DefineComponent<ExtractPropTypes<    {
progress: PropType<number>;
uid: PropType<string>;
status: PropType<UploadFileStatus>;
async: PropType<UploadAsyncProps>;
disabled: PropType<boolean>;
files: PropType<any[]>;
}>, {
kendoLocalizationService: {};
}, {
retryFocused: boolean;
actionFocused: boolean;
}, {}, {
actionButtonTitle(status: UploadFileStatus, localizationService: LocalizationService): string;
retryButtonTitle(localizationService: LocalizationService): string;
buttonClassNames(type: string): string;
onRetryFocus(): void;
onRetryBlur(): void;
onActionFocus(): void;
onActionBlur(): void;
onActionClick(): void;
onRetryClick(): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
cancel: any;
retry: any;
remove: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
progress: PropType<number>;
uid: PropType<string>;
status: PropType<UploadFileStatus>;
async: PropType<UploadAsyncProps>;
disabled: PropType<boolean>;
files: PropType<any[]>;
}>> & Readonly<{
onCancel?: (...args: any[] | unknown[]) => any;
onRemove?: (...args: any[] | unknown[]) => any;
onRetry?: (...args: any[] | unknown[]) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Represents the properties of the Kendo Ui for Vue UploadList Item component.
 */
export declare interface UploadListItemProps {
    /**
     * One or more files for the current item.
     */
    files: Array<UploadFileInfo>;
    /**
     * The `disabled` property of the Upload.
     */
    disabled: boolean;
    /**
     * The asynchronous properties of the Upload.
     */
    async: UploadAsyncProps;
}

/**
 * @hidden
 */
export declare const UploadListMultiItem: DefineComponent<ExtractPropTypes<    {
files: PropType<UploadFileInfo[]>;
disabled: PropType<boolean>;
async: PropType<UploadAsyncProps_2>;
}>, {
kendoLocalizationService: {};
}, {}, {}, {
onRetry(uid: string): void;
onRemove(uid: string): void;
onCancel(uid: string): void;
getFileValidationMessage(file: UploadFileInfo): string;
progress(): number;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
cancel: any;
retry: any;
remove: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
files: PropType<UploadFileInfo[]>;
disabled: PropType<boolean>;
async: PropType<UploadAsyncProps_2>;
}>> & Readonly<{
onCancel?: (...args: any[] | unknown[]) => any;
onRemove?: (...args: any[] | unknown[]) => any;
onRetry?: (...args: any[] | unknown[]) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * @hidden
 */
export declare const UploadListSingleItem: DefineComponent<ExtractPropTypes<    {
files: PropType<UploadFileInfo[]>;
disabled: PropType<boolean>;
async: PropType<UploadAsyncProps_2>;
}>, {
kendoLocalizationService: {};
}, {}, {}, {
onRetry(uid: string): void;
onRemove(uid: string): void;
onCancel(uid: string): void;
getFileExtension(file: UploadFileInfo): string;
getFileValidationMessage(file: UploadFileInfo, isUploadFailed: boolean): string;
getFileExtensionName(file: UploadFileInfo): string;
getFileExtensionSVG(file: UploadFileInfo): SVGIcon;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
cancel: any;
retry: any;
remove: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
files: PropType<UploadFileInfo[]>;
disabled: PropType<boolean>;
async: PropType<UploadAsyncProps_2>;
}>> & Readonly<{
onCancel?: (...args: any[] | unknown[]) => any;
onRemove?: (...args: any[] | unknown[]) => any;
onRetry?: (...args: any[] | unknown[]) => any;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * The `onAdd` event.
 */
export declare interface UploadOnAddEvent extends BaseUploadEvent<any> {
    /**
     * The new updated state candidate.
     */
    newState: Array<UploadFileInfo>;
    /**
     * The list of affected files.
     */
    affectedFiles: Array<UploadFileInfo>;
}

/**
 * The `onBeforeRemove` event.
 */
export declare interface UploadOnBeforeRemoveEvent extends BaseUploadEvent<any> {
    /**
     * The files that will be sent with the request.
     */
    files: Array<UploadFileInfo>;
    /**
     * The headers that will be sent with the request. Can be modified.
     */
    headers: UploadHttpHeaders;
    /**
     * The additional data that will be sent with the request. Can be modified.
     */
    additionalData: UploadAdditionalData;
}

/**
 * The `onBeforeUpload` event.
 */
export declare interface UploadOnBeforeUploadEvent extends BaseUploadEvent<any> {
    /**
     * The files that will be sent with the request.
     */
    files: Array<UploadFileInfo>;
    /**
     * The headers that will be sent with the request. Can be modified.
     */
    headers: UploadHttpHeaders;
    /**
     * The additional data that will be sent with the request. Can be modified.
     */
    additionalData: UploadAdditionalData;
}

/**
 * The `onCancel` event.
 */
export declare interface UploadOnCancelEvent extends BaseUploadEvent<any> {
    /**
     * The unique identifier of the group (batch) of one or more files that is cancelled.
     */
    uid: string;
}

/**
 * The `onProgress` event.
 */
export declare interface UploadOnProgressEvent extends BaseUploadEvent<any> {
    /**
     * The new updated state candidate.
     */
    newState: Array<UploadFileInfo>;
    /**
     * The list of the affected files.
     */
    affectedFiles: Array<UploadFileInfo>;
}

/**
 * The `onRemove` event.
 */
export declare interface UploadOnRemoveEvent extends BaseUploadEvent<any> {
    /**
     * The new updated state candidate.
     */
    newState: Array<UploadFileInfo>;
    /**
     * The list of the affected files.
     */
    affectedFiles: Array<UploadFileInfo>;
    /**
     * The server response (if available).
     */
    response?: UploadResponse;
}

/**
 * The `onStatusChange` event.
 */
export declare interface UploadOnStatusChangeEvent extends BaseUploadEvent<any> {
    /**
     * The new updated state candidate.
     */
    newState: Array<UploadFileInfo>;
    /**
     * The list of the affected files.
     */
    affectedFiles: Array<UploadFileInfo>;
    /**
     * The server response (if available).
     */
    response?: UploadResponse;
}

/**
 * Represents the props of the [Kendo Ui for Vue Upload component]({% slug overview_upload %}).
 */
export declare interface UploadProps extends UploadAsyncProps {
    /**
     * Sets a class of the Upload DOM element.
     */
    className?: string;
    /**
     * Enables the selection of multiple files
     * ([see example]({% slug fileprocessing_upload %}#toc-upload-of-single-or-multiple-files)).
     * If set to `false`, only one file can be selected at a time.
     */
    multiple?: boolean;
    /**
     * Disables the Upload ([see example]({% slug disabledstate_upload %})). Defaults to `false`.
     */
    disabled?: boolean;
    /**
     * Toggles the visibility of the file list.
     */
    showFileList?: boolean;
    /**
     * When the `autoUpload` option is set to `false`,
     * `showActionButtons` toggles the visibility of the action buttons which are rendered.
     */
    showActionButtons?: boolean;
    /**
     * Specifies the possible layouts of the action buttons
     *  ([see example]({% slug actionbuttons_upload %})). Defaults to `end`.
     */
    actionsLayout?: UploadActionsLayout;
    /**
     * Specifies the [`tabindex`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex)
     * of the Upload.
     */
    tabIndex?: number | string;
    /**
     * Specifies the id of the component.
     */
    id?: string;
    /**
     * Identifies the element(s) which will describe the component, similar
     *  to HTML aria-describedby attribute For example these elements
     * could contain error or hint message.
     */
    ariaDescribedBy?: string;
    /**
     * Identifies the element(s) which will label the component.
     */
    ariaLabelledBy?: string;
    /**
     * Sets the `accept` attribute of the `input` element of the Upload.
     */
    accept?: string;
    /**
     * Sets the restrictions for the selected files ([see example]({% slug filerestrictions_upload %})).
     */
    restrictions?: UploadFileRestrictions;
    /**
     * Sets the custom restrictions for the selected files ([see example]({% slug filerestrictions_upload %})).
     */
    validateFile?: (file: UploadFileInfo) => void;
    /**
     * The list of files which are displayed when the Upload is in controlled mode
     * ([see example]({% slug controleduncontroled_upload %})).
     */
    files?: Array<UploadFileInfo>;
    /**
     * The initial list of files which are displayed when the Upload is in
     * uncontrolled mode ([see example]({% slug controleduncontroled_upload %})).
     */
    defaultFiles?: Array<UploadFileInfo>;
    /**
     * The component that will be rendered as a list item inside the Upload.
     */
    list?: any;
    /**
     * Fires when new files are selected for upload.
     */
    onAdd?: (event: UploadOnAddEvent) => void;
    /**
     * Fires when files are removed. Optionally, if a request is made, can contain a server response.
     */
    onRemove?: (event: UploadOnRemoveEvent) => void;
    /**
     * Fires when the status of the files is changed. Optionally, if a request is made, can contain a server response.
     */
    onStatuschange?: (event: UploadOnStatusChangeEvent) => void;
    /**
     * Fires when the progress of the file upload is changed.
     */
    onProgress?: (event: UploadOnProgressEvent) => void;
    /**
     * Fires before a request for a file upload is made. Can be used to add extra data to the request.
     */
    onBeforeupload?: (event: UploadOnBeforeUploadEvent) => void;
    /**
     * Fires before a request for a file removal is made. Can be used to add extra data to the request.
     */
    onBeforeremove?: (event: UploadOnBeforeRemoveEvent) => void;
    /**
     * Fires when user clicks on the **Remove** button while the file upload is in progress.
     * Can be used when the `saveUrl` option is set to a function that cancels custom requests.
     */
    onCancel?: (event: UploadOnCancelEvent) => void;
}

/**
 * Represents the response type of the Upload.
 */
export declare interface UploadResponse {
    /**
     * The response that was provided by the server.
     */
    response: any;
    /**
     * The HTTP status code from the server response.
     */
    status: number;
    /**
     * The HTTP status message from the server response.
     */
    statusText: string;
    /**
     * The headers with which the server responded.
     */
    headers: any;
    /**
     * The XMLHttpRequest instance of the browser.
     */
    request?: XMLHttpRequest;
}

/**
 * @hidden
 */
export declare const UploadUI: DefineComponent<ExtractPropTypes<    {
async: PropType<Object>;
className: PropType<string>;
multiple: {
type: PropType<boolean>;
default: boolean;
};
disabled: {
type: PropType<boolean>;
default: boolean;
};
showFileList: PropType<boolean>;
showActionButtons: PropType<boolean>;
actionsLayout: {
type: PropType<string>;
default: () => string;
};
tabIndex: PropType<number>;
accept: PropType<string>;
groupedFiles: {
type: PropType<GroupedFiles>;
default: () => {};
};
navigationIndex: PropType<number>;
notFocusedIndex: PropType<number>;
list: PropType<any>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
}>, {
containerRef: Ref<any, any>;
uploadDropZoneRef: Ref<any, any>;
}, {}, {
groupsCount(): number;
lastGroupIndex(): number;
addButtonIndex(): number;
clearButtonIndex(): number;
uploadButtonIndex(): number;
isRtl(): boolean;
}, {
actionElement(): any;
focus(): any;
onAdd(files: FileList): void;
onRetry(uid: string): void;
onCancel(uid: string): void;
onClear(): void;
onUpload(): void;
onRemove(uid: string): void;
onKeyDown(event: KeyboardEvent): void;
onFocus(event: any): void;
onBlur(event: any): void;
onClick(navIndex: number | undefined): void;
}, ComponentOptionsMixin, ComponentOptionsMixin, {
add: any;
retry: any;
cancel: any;
clear: any;
upload: any;
remove: any;
keydown: any;
click: any;
focus: any;
blur: any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
async: PropType<Object>;
className: PropType<string>;
multiple: {
type: PropType<boolean>;
default: boolean;
};
disabled: {
type: PropType<boolean>;
default: boolean;
};
showFileList: PropType<boolean>;
showActionButtons: PropType<boolean>;
actionsLayout: {
type: PropType<string>;
default: () => string;
};
tabIndex: PropType<number>;
accept: PropType<string>;
groupedFiles: {
type: PropType<GroupedFiles>;
default: () => {};
};
navigationIndex: PropType<number>;
notFocusedIndex: PropType<number>;
list: PropType<any>;
id: PropType<string>;
ariaLabelledBy: PropType<string>;
ariaDescribedBy: PropType<string>;
}>> & Readonly<{
onClick?: (...args: any[] | unknown[]) => any;
onBlur?: (...args: any[] | unknown[]) => any;
onCancel?: (...args: any[] | unknown[]) => any;
onFocus?: (...args: any[] | unknown[]) => any;
onKeydown?: (...args: any[] | unknown[]) => any;
onClear?: (...args: any[] | unknown[]) => any;
onAdd?: (...args: any[] | unknown[]) => any;
onRemove?: (...args: any[] | unknown[]) => any;
onRetry?: (...args: any[] | unknown[]) => any;
onUpload?: (...args: any[] | unknown[]) => any;
}>, {
disabled: boolean;
multiple: boolean;
groupedFiles: GroupedFiles;
actionsLayout: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * @hidden
 */
export declare interface UploadUIProps extends UploadAsyncProps {
    className?: string;
    multiple?: boolean;
    disabled?: boolean;
    showFileList?: boolean;
    showActionButtons?: boolean;
    actionsLayout?: string;
    tabIndex?: number;
    accept?: string;
    groupedFiles: GroupedFiles;
    navigationIndex?: number;
    notFocusedIndex?: number;
    list?: any;
    id?: string;
    ariaLabelledBy?: string;
    ariaDescribedBy?: string;
    async?: Object;
    addButtonIndex?: number;
    restrictions?: UploadFileRestrictions;
    files: UploadFileInfo[];
    defaultFiles?: UploadFileInfo[];
}

/**
 * @hidden
 */
export declare const utils: {
    fileHasValidationErrors: Function;
    filesHaveValidationErrors: Function;
    getTotalFilesSizeMessage: Function;
    getAllFileInfo: Function;
    getFileInfo: Function;
    getFileExtension: Function;
    htmlEncode: Function;
    assignGuidToFiles: Function;
    getFileStatus: (currentFiles: GroupedFiles | UploadFileInfo[]) => boolean[];
};

export { }