@progress/kendo-angular-upload 24.2.2 → 25.0.0-develop.2

package/index.d.ts

@@ -2,32 +2,1997 @@
 * Copyright © 2026 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-export { UploadService } from './upload.service';
-export { NavigationService } from './navigation.service';
-export { DropZoneService } from './dropzone.service';
-export { FileSelectModule } from './fileselect.module';
-export { UploadModule } from './upload.module';
-export { UploadsModule } from './uploads.module';
-export { UploadComponent } from './upload.component';
-export { FileSelectComponent } from './fileselect.component';
-export { UploadDropZoneComponent } from './dropzone.component';
-export { FileSelectDirective } from './file-select.directive';
-export { FileListComponent } from './rendering/file-list.component';
-export { FileListItemBase } from './rendering/file-list-item-base';
-export { FileListSingleItemComponent } from './rendering/file-list-single-item.component';
-export { FileListItemActionButtonComponent } from './rendering/file-list-item-action-button.component';
-export { FileListMultipleItemsComponent } from './rendering/file-list-multiple-items.component';
-export { FileTemplateDirective } from './templates/file-template.directive';
-export { FileInfoTemplateDirective } from './templates/file-info-template.directive';
-export { UploadStatusTotalComponent } from './rendering/upload-status-total.component';
-export { UploadActionButtonsComponent } from './rendering/upload-action-buttons.component';
-export { UploadDropZoneDirective } from './dropzone-external.directive';
-export { CustomMessagesComponent } from './localization/custom-messages.component';
-export { ActionsLayout } from './common/action-buttons-layout';
-export { validateFiles } from './common/validation-util';
-export { UPLOAD_VALUE_ACCESSOR } from './upload.component';
-export { getTotalFilesSizeMessage, fileSVGGroupIcon, fileGroupClass } from './common/util';
-export { FileSelectSettings } from './common/fileselect-settings';
-export * from './events';
-export * from './types';
-export * from './directives';
+import { HttpHeaders, HttpResponse, HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { EventEmitter, NgZone, TemplateRef, ChangeDetectorRef, Injector, ElementRef, OnInit, OnDestroy, Renderer2, DoCheck, QueryList } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { FormControl, ControlValueAccessor } from '@angular/forms';
+import { LocalizationService, ComponentMessages } from '@progress/kendo-angular-l10n';
+import { SVGIcon } from '@progress/kendo-svg-icons';
+import { SVGIcon as SVGIcon$1 } from '@progress/kendo-angular-icons';
+
+/**
+ * @hidden
+ */
+interface AsyncSettings {
+    autoUpload?: boolean;
+    batch?: boolean;
+    chunk?: boolean;
+    concurrent?: boolean;
+    removeField?: string;
+    removeHeaders?: HttpHeaders;
+    removeMethod?: string;
+    removeUrl?: string;
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    saveField?: string;
+    saveHeaders?: HttpHeaders;
+    saveMethod?: string;
+    saveUrl: string;
+    withCredentials?: boolean;
+}
+
+/**
+ * The settings for the Upload chunk functionality.
+ */
+interface ChunkSettings {
+    /**
+     * The size of the chunks in bytes.
+     *
+     * @default 1048576
+     */
+    size?: number;
+    /**
+     * The number of milliseconds to wait before retrying a failed chunk upload.
+     *
+     * @default 100
+     */
+    autoRetryAfter?: number;
+    /**
+     * The number of attempts to retry uploading a failed chunk.
+     *
+     * @default 1
+     */
+    maxAutoRetries?: number;
+    /**
+     * Specifies whether the file upload process can be paused and later resumed.
+     *
+     * @default true
+     */
+    resumable?: boolean;
+}
+
+/**
+ * Contains information related to the uploaded file.
+ * Use this metadata to process file chunks and merge them into a file on the back-end.
+ */
+interface ChunkMetadata {
+    /**
+     * The MIME type of the file.
+     */
+    contentType: string;
+    /**
+     * The file name.
+     */
+    fileName: string;
+    /**
+     * The file size in bytes.
+     */
+    fileSize: number;
+    /**
+     * The unique identifier of the file.
+     */
+    fileUid: string;
+    /**
+     * The index of the currently uploaded chunk.
+     */
+    chunkIndex: number;
+    /**
+     * The total number of chunks that the file is split into.
+     */
+    totalChunks: number;
+}
+
+/**
+ * Lists the possible states of a file.
+ */
+declare enum FileState {
+    /**
+     * The file upload process failed.
+     */
+    Failed = 0,
+    /**
+     * An initially selected file without a set state.
+     */
+    Initial = 1,
+    /**
+     * The file is selected.
+     */
+    Selected = 2,
+    /**
+     * The file uploaded successfully.
+     */
+    Uploaded = 3,
+    /**
+     * The file is uploading.
+     */
+    Uploading = 4,
+    /**
+     * The file upload process is paused.
+     */
+    Paused = 5
+}
+
+/**
+ * Contains information which is related to the selected file.
+ */
+interface FileInfo {
+    /**
+     * The unique identifier of the file or the batch of files.
+     */
+    uid?: string;
+    /**
+     * The file name.
+     */
+    name: string;
+    /**
+     * The file extension including the leading dot—for example, `.jpg`, `.png`, or other.
+     */
+    extension?: string;
+    /**
+     * The file size in bytes.
+     */
+    size?: number;
+    /**
+     * An in-memory representation of the file.
+     */
+    rawFile?: File;
+    /**
+     * A list containing 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`.
+     * It is automatically applied to initial files without you having to explicitly set their state.
+     */
+    state?: FileState;
+    /**
+     * The observable subscription of the upload request.
+     */
+    httpSubscription?: Subscription;
+}
+
+/**
+ * Configures the restrictions for the files that can be uploaded.
+ */
+interface FileRestrictions {
+    /**
+     * The list of allowed file extensions
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/uploads/upload/restrictions#file-extension)).
+     * Accepts entries of both `.type` (for example, `.docx`, `.png`, `.svg`, `.xls`) and `type` (for example, `docx`, `png`, `svg`, `xls`) values.
+     */
+    allowedExtensions?: Array<string>;
+    /**
+     * The maximum file size in bytes
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/uploads/upload/restrictions#maximum-file-size)).
+     */
+    maxFileSize?: number;
+    /**
+     * The minimum file size in bytes
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/uploads/upload/restrictions#minimum-file-size)).
+     */
+    minFileSize?: number;
+}
+
+/**
+ * The operation (`upload` or `remove`) for which the `success` or `error` event is raised.
+ */
+type OperationType = "upload" | "remove";
+
+/**
+ * @hidden
+ */
+declare class FileMap {
+    private _files;
+    constructor();
+    add(file: FileInfo): void;
+    remove(uid: string): void;
+    clear(): void;
+    has(uid: string): boolean;
+    get(uid: string): Array<FileInfo>;
+    setFilesState(files: Array<FileInfo>, state: FileState): void;
+    setFilesStateByUid(uid: string, state: FileState): void;
+    get count(): number;
+    get files(): Array<Array<FileInfo>>;
+    get filesFlat(): Array<FileInfo>;
+    get filesToUpload(): Array<Array<FileInfo>>;
+    get firstFileToUpload(): Array<FileInfo>;
+    getFilesWithState(state: FileState): Array<FileInfo>;
+    hasFileWithState(fileStates: Array<FileState>): boolean;
+}
+
+/**
+ * Arguments for the `cancel` event. The `cancel` event fires when
+ * you cancel the upload of a file or batch of files.
+ *
+ * ```typescript
+ * @Component({
+ *    template: `
+ *    <kendo-upload (cancel)="cancelEventHandler($event)"></kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public cancelEventHandler(e: CancelEvent) {
+ *      console.log('Canceling file upload', e.files);
+ *    }
+ * }
+ * ```
+ */
+declare class CancelEvent {
+    /**
+     * The files that you canceled during the upload process.
+     */
+    files: Array<FileInfo>;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `cancel` event.
+     * @param files - The list of the files that were going to be uploaded.
+     */
+    constructor(files: Array<FileInfo>);
+}
+
+/**
+ * @hidden
+ */
+declare abstract class PreventableEvent {
+    private prevented;
+    /**
+     * Prevents the default action for a specified event.
+     * In this way, the source component suppresses the built-in behavior that follows the event.
+     */
+    preventDefault(): void;
+    /**
+     * If the event is prevented by any of its subscribers, returns `true`.
+     *
+     * @returns `true` if the default action was prevented. Otherwise, returns `false`.
+     */
+    isDefaultPrevented(): boolean;
+}
+
+/**
+ * Arguments for the `clear` event. The `clear` event fires when
+ * the **Clear** button is clicked and selected files are about to be cleared.
+ *
+ * ```typescript
+ * @Component({
+ *    template: `
+ *    <kendo-upload (clear)="clearEventHandler($event)"></kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public clearEventHandler(e: ClearEvent) {
+ *      console.log('Clearing the file upload');
+ *    }
+ * }
+ * ```
+ */
+declare class ClearEvent extends PreventableEvent {
+    /**
+     * @hidden
+     * Constructs the event arguments for the `clear` event.
+     */
+    constructor();
+}
+
+/**
+ * Arguments for the `error` event. The `error` event fires when
+ * an `upload` or `remove` operation fails.
+ *
+ * ```typescript
+ * @Component({
+ *    template: `
+ *    <kendo-upload (error)="errorEventHandler($event)"></kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *   public errorEventHandler(e: ErrorEvent) {
+ *      console.log('An error occurred');
+ *    }
+ * }
+ * ```
+ */
+declare class ErrorEvent {
+    /**
+     * The array of files that failed to be uploaded or removed.
+     */
+    files: Array<FileInfo>;
+    /**
+     * The operation type that failed (`upload` or `remove`).
+     */
+    operation: OperationType;
+    /**
+     * The HTTP response returned by the server containing error details.
+     */
+    response: HttpResponse<any>;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `error` event.
+     *
+     * @param files - The list of the files that failed to be uploaded or removed.
+     * @param operation - The operation type (`upload` or `remove`).
+     * @param response - The response object returned by the server.
+     */
+    constructor(files: Array<FileInfo>, operation: OperationType, response: HttpResponse<any>);
+}
+
+/**
+ * Arguments for the `pause` event. The `pause` event fires when
+ * you pause a file that is currently uploading.
+ *
+ * ```typescript
+ *  @Component({
+ *    template: `
+ *    <kendo-upload
+ *      [chunkable]="true"
+ *      (pause)="pauseEventHandler($event)">
+ *    </kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public pauseEventHandler(ev: PauseEvent) {
+ *      console.log('File paused');
+ *    }
+ *  }
+ * ```
+ */
+declare class PauseEvent {
+    /**
+     * The file that you paused during the upload process.
+     */
+    file: FileInfo;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `pause` event.
+     * @param file - The file that is going to be paused.
+     */
+    constructor(file: FileInfo);
+}
+
+/**
+ * Arguments for the `remove` event. The `remove` event fires when you are about to remove an uploaded
+ * or selected file. You can cancel this event to prevent removal.
+ *
+ * ```typescript
+ *  @Component({
+ *    template: `
+ *    <kendo-upload (remove)="removeEventHandler($event)"></kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public removeEventHandler(e: RemoveEvent) {
+ *      console.log('Removing a file');
+ *    }
+ *  }
+ * ```
+ */
+declare class RemoveEvent extends PreventableEvent {
+    /**
+     * An optional object that you send to the `remove` handler as key/value pairs.
+     *
+     */
+    data: object;
+    /**
+     * The files that you will remove from the server.
+     */
+    files: Array<FileInfo>;
+    /**
+     * The headers of the request.
+     * You can use this to add custom headers to the remove request.
+     */
+    headers: HttpHeaders;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `remove` event.
+     * @param files - The list of the files that will be removed.
+     * @param headers - The headers of the request.
+     */
+    constructor(files: Array<FileInfo>, headers: HttpHeaders);
+}
+
+/**
+ * Arguments for the `resume` event. The `resume` event fires when
+ * you resume a previously paused file upload.
+ *
+ * ```typescript
+ *  @Component({
+ *    template: `
+ *    <kendo-upload
+ *      [chunkable]="true"
+ *      (resume)="resumeEventHandler($event)">
+ *    </kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public resumeEventHandler(ev: ResumeEvent) {
+ *      console.log('File resumed');
+ *    }
+ *  }
+ * ```
+ */
+declare class ResumeEvent {
+    /**
+     * The file that you resumed during the upload process.
+     */
+    file: FileInfo;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `resume` event.
+     * @param file - The file that is going to be resumed.
+     */
+    constructor(file: FileInfo);
+}
+
+/**
+ * Arguments for the `select` event. The `select` event fires when
+ * a file or multiple files are selected for upload. The event can be canceled to prevent selection.
+ *
+ * ```typescript
+ *  @Component({
+ *    template: `
+ *    <kendo-upload (select)="selectEventHandler($event)"></kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public selectEventHandler(e: SelectEvent) {
+ *      console.log('File selected');
+ *    }
+ *  }
+ * ```
+ */
+declare class SelectEvent extends PreventableEvent {
+    /**
+     * The files that are selected for upload.
+     */
+    files: Array<FileInfo>;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `select` event.
+     * @param files - The list of the selected files.
+     */
+    constructor(files: Array<FileInfo>);
+}
+
+/**
+ * Arguments for the `success` event. The `success` event fires when
+ * you successfully upload or remove the selected files.
+ *
+ * ```typescript
+ *  @Component({
+ *    template: `
+ *    <kendo-upload (success)="successEventHandler($event)"></kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public successEventHandler(e: SuccessEvent) {
+ *      console.log('The ' + e.operation + ' was successful!');
+ *    }
+ *  }
+ * ```
+ */
+declare class SuccessEvent extends PreventableEvent {
+    /**
+     * The files that you successfully uploaded or removed.
+     */
+    files: Array<FileInfo>;
+    /**
+     * The operation type that succeeded (`upload` or `remove`).
+     */
+    operation: OperationType;
+    /**
+     * The HTTP response that the server returns to confirm success.
+     */
+    response: HttpResponse<any>;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `success` event.
+     * @param files - The list of the files that were uploaded or removed.
+     * @param operation - The operation type (`upload` or `remove`).
+     * @param response - The response object returned by the server.
+     */
+    constructor(files: Array<FileInfo>, operation: OperationType, response: HttpResponse<any>);
+}
+
+/**
+ * Arguments for the `upload` event. The `upload` event fires when you are about
+ * to upload one or more files. You can cancel this event to prevent upload and add headers to the request.
+ *
+ * ```typescript
+ *  @Component({
+ *    template: `
+ *    <kendo-upload (upload)="uploadEventHandler($event)"></kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public uploadEventHandler(e: UploadEvent) {
+ *      e.headers = e.headers.append('X-Foo', 'Bar');
+ *    }
+ *  }
+ * ```
+ */
+declare class UploadEvent extends PreventableEvent {
+    /**
+     * The optional object that you send to the `upload` handler as key/value pairs.
+     *
+     */
+    data: object;
+    /**
+     * The files that you will upload to the server.
+     */
+    files: Array<FileInfo>;
+    /**
+     * The headers of the request.
+     * You can use this to add custom headers to the upload request.
+     */
+    headers: HttpHeaders;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `upload` event.
+     * @param files - The list of the files that will be uploaded.
+     * @param headers - The headers of the request.
+     */
+    constructor(files: Array<FileInfo>, headers: HttpHeaders);
+}
+
+/**
+ * Arguments for the `uploadprogress` event. The `uploadprogress` event
+ * fires when you upload files.
+ *
+ * ```typescript
+ *  @Component({
+ *    template: `
+ *    <kendo-upload (uploadProgress)="uploadProgressEventHandler($event)"></kendo-upload>
+ *    `
+ *  })
+ *  export class UploadComponent {
+ *    public uploadProgressEventHandler(e: UploadProgressEvent) {
+ *      console.log(e.files[0].name + ' is ' + e.percentComplete + ' uploaded');
+ *    }
+ *  }
+ * ```
+ */
+declare class UploadProgressEvent {
+    /**
+     * The files that you are currently uploading.
+     */
+    files: Array<FileInfo>;
+    /**
+     * The upload progress as a percentage from 0 to 100.
+     */
+    percentComplete: number;
+    /**
+     * @hidden
+     * Constructs the event arguments for the `uploadprogress` event.
+     * @param files - The list of files that are being uploaded.
+     * @param percentComplete - The portion that has been uploaded.
+     */
+    constructor(files: Array<FileInfo>, percentComplete: number);
+}
+
+/**
+ * @hidden
+ */
+type ComponentType = 'FileSelect' | 'Upload';
+/**
+ * @hidden
+ */
+declare class UploadService {
+    private http;
+    cancelEvent: EventEmitter<CancelEvent>;
+    clearEvent: EventEmitter<ClearEvent>;
+    completeEvent: EventEmitter<any>;
+    errorEvent: EventEmitter<ErrorEvent>;
+    pauseEvent: EventEmitter<PauseEvent>;
+    removeEvent: EventEmitter<RemoveEvent>;
+    resumeEvent: EventEmitter<ResumeEvent>;
+    selectEvent: EventEmitter<SelectEvent>;
+    successEvent: EventEmitter<SuccessEvent>;
+    uploadEvent: EventEmitter<UploadEvent>;
+    uploadProgressEvent: EventEmitter<UploadProgressEvent>;
+    /**
+     * Required for the `ControlValueAccessor` integration
+     */
+    changeEvent: EventEmitter<Array<FileInfo>>;
+    /**
+     * Default async settings
+     */
+    async: AsyncSettings;
+    /**
+     * Default chunk settings
+     */
+    chunk: ChunkSettings;
+    component: ComponentType;
+    private chunkMap;
+    private fileList;
+    constructor(http: HttpClient);
+    get files(): FileMap;
+    setChunkSettings(settings: ChunkSettings | boolean): void;
+    onChange(): void;
+    addFiles(files: Array<FileInfo>): void;
+    addInitialFiles(initialFiles: Array<FileInfo>): void;
+    addInitialFileSelectFiles(initialFiles: Array<any>): void;
+    resumeFile(uid: string): void;
+    pauseFile(uid: string): void;
+    removeFiles(uid: string): void;
+    cancelFiles(uid: string): void;
+    clearFiles(): void;
+    uploadFiles(): void;
+    retryFiles(uid: string): void;
+    private _uploadFiles;
+    private performRemove;
+    private performUpload;
+    private onSuccess;
+    private onError;
+    private onProgress;
+    private onChunkProgress;
+    private checkAllComplete;
+    private shouldUploadNextFile;
+    private areAllSelectedFilesHandled;
+    private cloneRequestHeaders;
+    private populateRequestOptions;
+    private populateUploadFormData;
+    private populateRemoveFormData;
+    private populateClientFormData;
+    private getNextChunk;
+    private getChunkInfo;
+    private updateChunkInfo;
+    private removeChunkInfo;
+    private getChunkMetadata;
+    private isChunkUploadComplete;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UploadService>;
+}
+
+/**
+ * @hidden
+ */
+declare class NavigationService {
+    private uploadService;
+    private zone;
+    onActionButtonFocus: EventEmitter<string>;
+    onFileAction: EventEmitter<string>;
+    onFileFocus: EventEmitter<number>;
+    onTabOut: EventEmitter<any>;
+    onWrapperFocus: EventEmitter<any>;
+    onSelectButtonFocus: EventEmitter<any>;
+    actionButtonsVisible: boolean;
+    fileListVisible: boolean;
+    focused: boolean;
+    keyBindings: object;
+    focusedFileIndex: number;
+    private _focusedIndex;
+    constructor(uploadService: UploadService, zone: NgZone);
+    action(event: KeyboardEvent): Function;
+    process(event: KeyboardEvent, component?: string): void;
+    computeKeys(): void;
+    focusSelectButton(): void;
+    handleEnter(): void;
+    handleSpace(): void;
+    handleDelete(): void;
+    handleEscape(): void;
+    handleTab(event: any, component: any): void;
+    handleUpDown(event: any, direction: any): void;
+    get focusedIndex(): number;
+    set focusedIndex(index: number);
+    get lastFileIndex(): number;
+    get lastIndex(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}
+
+/**
+ * @hidden
+ */
+type Direction = 'rtl' | 'ltr';
+
+/**
+ * Specifies the layout options for the Upload action buttons.
+ */
+type ActionsLayout = 'start' | 'center' | 'end' | 'stretched';
+
+/**
+ * Customizes the rendering of files in the list. ([See example.](https://www.telerik.com/kendo-angular-ui/components/uploads/upload/templates#file-template))
+ *
+ * The following context variables are available in the template:
+ *
+ * * `let-files`&mdash;A reference to the files associated with the current item.
+ * * `let-state`&mdash;A reference to the current state of each file. If the [`batch`](https://www.telerik.com/kendo-angular-ui/components/uploads/api/uploadcomponent#batch) option of the Upload is set to `true`, the field reflects the state of the whole batch.
+ * * `#myUpload="kendoUpload"` or `#myFileSelect="kendoFileSelect"`&mdash;A reference to the instance of the Upload/FileSelect component. It is exported as `kendoUpload`/`kendoFileSelect` by using the [`exportAs`](https://angular.io/api/core/Component) metadata property.
+ *
+ * @example
+ * ```html
+ * <kendo-upload #myUpload="kendoUpload">
+ *     <ng-template kendoUploadFileTemplate let-files let-state>
+ *         <div>Name: {{ files[0].name }} Size: {{ files[0].size }} bytes</div>
+ *     </ng-template>
+ * </kendo-upload>
+ * ```
+ */
+declare class FileTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileTemplateDirective, "[kendoUploadFileTemplate], [kendoFileSelectFileTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Customizes the rendering of the file info section in the list. All other elements of the default template, such as file icon, action buttons, and upload progress, are preserved in place. ([See example](https://www.telerik.com/kendo-angular-ui/components/uploads/upload/templates#file-info-template)).
+ *
+ * The following context variables are available in the template:
+ *
+ * * `let-files`&mdash;A reference to the files associated with the current item.
+ * * `let-state`&mdash;A reference to the current state of each file. If the [`batch`](https://www.telerik.com/kendo-angular-ui/components/uploads/api/uploadcomponent#batch) option of the Upload is set to `true`, the field reflects the state of the whole batch.
+ * * `#myUpload="kendoUpload"` or `#myFileSelect="kendoFileSelect"`&mdash;A reference to the instance of the Upload/FileSelect component. It is exported as `kendoUpload`/`kendoFileSelect` by using the [`exportAs`](https://angular.io/api/core/Component) metadata property.
+ *
+ * @example
+ * ```html
+ * <kendo-upload #myUpload="kendoUpload">
+ *     <ng-template kendoUploadFileInfoTemplate let-files let-state>
+ *         <div>Name: {{ files[0].name }}</div>
+ *     </ng-template>
+ * </kendo-upload>
+ * ```
+ */
+declare class FileInfoTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileInfoTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileInfoTemplateDirective, "[kendoUploadFileInfoTemplate], [kendoFileSelectFileInfoTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class UploadFileSelectBase {
+    protected uploadService: UploadService;
+    protected navigation: NavigationService;
+    protected cdr: ChangeDetectorRef;
+    protected injector: Injector;
+    protected zone: NgZone;
+    /**
+     * @hidden
+     */
+    fileTemplate: FileTemplateDirective;
+    /**
+     * @hidden
+     */
+    fileInfoTemplate: FileInfoTemplateDirective;
+    /**
+     * @hidden
+     */
+    fileSelectButton: ElementRef;
+    /**
+     * Sets the `accept` attribute of the internal `input` element of the component.
+     */
+    accept: string;
+    /**
+     * Disables the component.
+     *
+     * @default false
+     */
+    disabled: boolean;
+    /**
+     * Allows you to select multiple files.
+     * When you set this to `false`, you can select only one file at a time.
+     *
+     * @default true
+     */
+    multiple: boolean;
+    /**
+     * Controls the visibility of the file list.
+     *
+     * @default true
+     */
+    showFileList: boolean;
+    /**
+     * Sets the [`tabindex`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex) of the component.
+     *
+     * @default 0
+     */
+    tabindex: number;
+    /**
+     * Sets the restrictions for selected files.
+     */
+    set restrictions(restrictions: FileRestrictions);
+    get restrictions(): FileRestrictions;
+    /**
+     * Sets the `id` of the external drop zone that you want to associate with the component.
+     */
+    zoneId: string;
+    /**
+     * @hidden
+     */
+    focusableId: string;
+    /**
+     * @hidden
+     */
+    hostUploadClass: boolean;
+    /**
+     * @hidden
+     */
+    hostUploadAsyncClass: boolean;
+    /**
+     * @hidden
+     */
+    get hostDisabledClass(): boolean;
+    /**
+     * @hidden
+     */
+    get hostEmptyClass(): boolean;
+    /**
+     * Fires when you navigate outside the component.
+     */
+    onBlur: EventEmitter<any>;
+    /**
+     * Fires when you focus the component.
+     */
+    onFocus: EventEmitter<any>;
+    /**
+     * Fires when you select files. If you prevent this event, the component will not add the selected files to the list.
+     */
+    select: EventEmitter<SelectEvent>;
+    /**
+     * Fires when you are about to remove a file. If you prevent this event, the file will remain in the list.
+     */
+    remove: EventEmitter<RemoveEvent>;
+    /**
+     * @hidden
+     */
+    _restrictions: FileRestrictions;
+    /**
+     * @hidden
+     */
+    fileList: FileMap;
+    constructor(uploadService: UploadService, navigation: NavigationService, cdr: ChangeDetectorRef, injector: Injector, zone: NgZone);
+    /**
+     * @hidden
+     */
+    get formControl(): FormControl;
+    /**
+     * @hidden
+     */
+    get isControlRequired(): boolean;
+    /**
+     * @hidden
+     */
+    get hasFileList(): boolean;
+    /**
+     * @hidden
+     */
+    writeValue(newValue: any, validation: Function, callback: string): void;
+    protected onTouchedCallback: Function;
+    protected onChangeCallback: Function;
+    /**
+     * @hidden
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * @hidden
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * @hidden
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * @hidden
+     */
+    onFileSelectButtonFocus(): void;
+    /**
+     * Focuses the component's **Select files** button.
+     */
+    focus(): void;
+    /**
+     * @hidden
+     * @deprecated
+     */
+    focusComponent(): void;
+    /**
+     * Blurs the component if you previously focused it.
+     */
+    blur(): void;
+    /**
+     * @hidden
+     * @deprecated
+     */
+    blurComponent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadFileSelectBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UploadFileSelectBase, never, never, { "accept": { "alias": "accept"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "showFileList": { "alias": "showFileList"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "restrictions": { "alias": "restrictions"; "required": false; }; "zoneId": { "alias": "zoneId"; "required": false; }; "focusableId": { "alias": "focusableId"; "required": false; }; }, { "onBlur": "blur"; "onFocus": "focus"; "select": "select"; "remove": "remove"; }, ["fileTemplate", "fileInfoTemplate"], never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare const UPLOAD_VALUE_ACCESSOR: any;
+/**
+ * Represents the [Kendo UI Upload component for Angular](https://www.telerik.com/kendo-angular-ui/components/uploads).
+ *
+ * @example
+ * ```html
+ * <kendo-upload
+ *    [saveUrl]="uploadSaveUrl"
+ *    [removeUrl]="uploadRemoveUrl">
+ * </kendo-upload>
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link CustomMessagesComponent}
+ */
+declare class UploadComponent extends UploadFileSelectBase implements OnInit, OnDestroy, ControlValueAccessor {
+    protected uploadService: UploadService;
+    private localization;
+    protected navigation: NavigationService;
+    private dropZoneService;
+    protected zone: NgZone;
+    private renderer;
+    protected cdr: ChangeDetectorRef;
+    protected injector: Injector;
+    /**
+     * Specifies whether selected files upload automatically
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/uploads/upload/file-processing#automatic-upload-of-files)).
+     * Set `autoUpload` to `false` to change this behavior.
+     *
+     * @default true
+     */
+    set autoUpload(autoUpload: boolean);
+    get autoUpload(): boolean;
+    /**
+     * Specifies whether all files in the selection upload in a single request
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/uploads/upload/file-processing#upload-of-batches-of-files)).
+     * Files selected one after the other upload in separate requests.
+     *
+     * @default false
+     */
+    set batch(batch: boolean);
+    get batch(): boolean;
+    /**
+     * Specifies whether credentials (cookies, headers) are sent for cross-site requests
+     * ([see example](https://www.telerik.com/kendo-angular-ui/components/uploads/upload/credentials#attaching-credentials-to-requests)).
+     * Set `withCredentials` has no effect on same-site requests.
+     * Use the `saveHeaders` or `removeHeaders` property to add credentials to the request.
+     * You can also use the [`upload`](https://www.telerik.com/kendo-angular-ui/components/uploads/api/uploadevent) event.
+     *
+     * @default true
+     */
+    set withCredentials(withCredentials: boolean);
+    get withCredentials(): boolean;
+    /**
+     * Specifies the [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) key which contains the files submitted to `saveUrl`.
+     *
+     */
+    set saveField(saveField: string);
+    get saveField(): string;
+    /**
+     * Specifies the [`HttpHeaders`](https://angular.io/api/common/http/HttpHeaders) attached to each upload request.
+     */
+    set saveHeaders(saveHeaders: HttpHeaders);
+    get saveHeaders(): HttpHeaders;
+    /**
+     * Specifies the [`RequestMethod`](https://angular.io/api/http/RequestMethod) of the upload request.
+     *
+     */
+    set saveMethod(saveMethod: string);
+    get saveMethod(): string;
+    /**
+     * Specifies the URL of the endpoint for the upload request.
+     * The request [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) key uses the name from the `saveField` property.
+     * This key contains the list of files to be uploaded.
+     */
+    set saveUrl(saveUrl: string);
+    get saveUrl(): string;
+    /**
+     * Specifies the expected [`response type`](https://angular.io/api/common/http/HttpRequest#responseType) of the server.
+     * The response type determines how the response is parsed.
+     *
+     * @default 'json'
+     */
+    set responseType(responseType: 'arraybuffer' | 'blob' | 'json' | 'text');
+    get responseType(): 'arraybuffer' | 'blob' | 'json' | 'text';
+    /**
+     * Specifies the [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) key which contains the list of file names submitted to `removeUrl`.
+     *
+     */
+    set removeField(removeField: string);
+    get removeField(): string;
+    /**
+     * Specifies the [`HttpHeaders`](https://angular.io/api/common/http/HttpHeaders) attached to each `remove` request.
+     */
+    set removeHeaders(removeHeaders: HttpHeaders);
+    get removeHeaders(): HttpHeaders;
+    /**
+     * Specifies the [`RequestMethod`](https://angular.io/api/http/RequestMethod) of the `remove` request.
+     *
+     */
+    set removeMethod(removeMethod: string);
+    get removeMethod(): string;
+    /**
+     * Specifies the URL of the endpoint for the `remove` request.
+     * The [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) request key uses the name from the `removeField` property.
+     * This key contains the list of file names to be removed.
+     */
+    set removeUrl(removeUrl: string);
+    get removeUrl(): string;
+    /**
+     * Specifies whether the chunk functionality of the Upload is enabled.
+     *
+     * @default false
+     */
+    chunkable: ChunkSettings | boolean;
+    /**
+     * Specifies whether selected files upload simultaneously or one by one.
+     *
+     * @default true
+     */
+    set concurrent(concurrent: boolean);
+    get concurrent(): boolean;
+    /**
+     * Specifies whether the file list is visible.
+     *
+     * @default true
+     */
+    showFileList: boolean;
+    /**
+     * @hidden
+     */
+    set tabIndex(tabIndex: number);
+    get tabIndex(): number;
+    /**
+     * Specifies the layout of the action buttons.
+     *
+     * @default 'end'
+     */
+    actionsLayout: ActionsLayout;
+    fileSelectInput: ElementRef;
+    /**
+     * Fires when the upload is canceled while in progress.
+     */
+    cancel: EventEmitter<CancelEvent>;
+    /**
+     * Fires when the file list is about to be cleared.
+     * Prevent this event to keep the files in the list.
+     */
+    clear: EventEmitter<ClearEvent>;
+    /**
+     * Fires when all active uploads complete successfully or with errors.
+     */
+    complete: EventEmitter<any>;
+    /**
+     * Fires when an `upload` or `remove` operation fails.
+     */
+    error: EventEmitter<ErrorEvent>;
+    /**
+     * Fires when the upload of a file is paused.
+     */
+    pause: EventEmitter<any>;
+    /**
+     * Fires when the upload of a file is resumed.
+     */
+    resume: EventEmitter<any>;
+    /**
+     * Fires when an `upload` or `remove` operation completes successfully.
+     */
+    success: EventEmitter<SuccessEvent>;
+    /**
+     * Fires when one or more files are about to be uploaded.
+     * Prevent this event to stop the files from uploading and being added to the file list.
+     */
+    upload: EventEmitter<UploadEvent>;
+    /**
+     * Fires when one or more files are uploading.
+     */
+    uploadProgress: EventEmitter<UploadProgressEvent>;
+    /**
+     * Fires when the component value changes after a successful `upload`, `remove`, or `clear` operation.
+     */
+    valueChange: EventEmitter<Array<FileInfo>>;
+    get dir(): string;
+    direction: Direction;
+    wrapper: HTMLElement;
+    fileListId: string;
+    private documentClick;
+    private blurSubscription;
+    private wrapperFocusSubscription;
+    private selectButtonFocusSubscription;
+    private localizationChangeSubscription;
+    private subs;
+    constructor(uploadService: UploadService, localization: LocalizationService, navigation: NavigationService, dropZoneService: DropZoneService, zone: NgZone, renderer: Renderer2, cdr: ChangeDetectorRef, wrapper: ElementRef, injector: Injector);
+    ngOnInit(): void;
+    ngOnChanges(changes: any): void;
+    ngOnDestroy(): void;
+    /**
+     * @hidden
+     */
+    writeValue(newValue: any): void;
+    /**
+     * @hidden
+     */
+    get showActionButtons(): boolean;
+    /**
+     * @hidden
+     */
+    get showTotalStatus(): boolean;
+    /**
+     * @hidden
+     */
+    textFor(key: string): string;
+    /**
+     * @hidden
+     */
+    getIds(): {
+        buttonId: string;
+        fileListId: string;
+    };
+    /**
+     * Pauses the upload process of a file that is currently uploading.
+     * This method requires the `chunkable` option of the Upload to be enabled.
+     *
+     * @param uid The `uid` of the file that will be paused.
+     */
+    pauseFileByUid(uid: string): void;
+    /**
+     * Resumes the upload process for a file that was previously paused.
+     * This method requires the `chunkable` option of the Upload to be enabled.
+     *
+     * @param uid The `uid` of the file that will be resumed.
+     */
+    resumeFileByUid(uid: string): void;
+    /**
+     * Removes a file or a batch of files.
+     *
+     * @param uid The `uid` of the file or a batch of files that will be removed.
+     */
+    removeFilesByUid(uid: string): void;
+    /**
+     * Retries the upload of a file or batch of files that failed to upload.
+     *
+     * @param uid The `uid` of the file or a batch of files to be retried.
+     */
+    retryUploadByUid(uid: string): void;
+    /**
+     * Cancels the upload of a file or a batch of files.
+     *
+     * @param uid The `uid` of the file or a batch of files that will be canceled.
+     */
+    cancelUploadByUid(uid: string): void;
+    /**
+     * Uploads the currently selected files that pass the set restrictions.
+     */
+    uploadFiles(): void;
+    /**
+     * Clears all files from the UI without sending requests to the remove handler.
+     */
+    clearFiles(): void;
+    /**
+     * @hidden
+     * Used by the external dropzone to add files to the Upload
+     */
+    addFiles(files: FileInfo[]): void;
+    /**
+     * @hidden
+     * Used to determine if the component is empty.
+     */
+    isEmpty(): boolean;
+    private verifySettings;
+    private subscribeBlur;
+    private handleKeydown;
+    private subscribeFocus;
+    private attachEventHandlers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadComponent, "kendo-upload", ["kendoUpload"], { "autoUpload": { "alias": "autoUpload"; "required": false; }; "batch": { "alias": "batch"; "required": false; }; "withCredentials": { "alias": "withCredentials"; "required": false; }; "saveField": { "alias": "saveField"; "required": false; }; "saveHeaders": { "alias": "saveHeaders"; "required": false; }; "saveMethod": { "alias": "saveMethod"; "required": false; }; "saveUrl": { "alias": "saveUrl"; "required": false; }; "responseType": { "alias": "responseType"; "required": false; }; "removeField": { "alias": "removeField"; "required": false; }; "removeHeaders": { "alias": "removeHeaders"; "required": false; }; "removeMethod": { "alias": "removeMethod"; "required": false; }; "removeUrl": { "alias": "removeUrl"; "required": false; }; "chunkable": { "alias": "chunkable"; "required": false; }; "concurrent": { "alias": "concurrent"; "required": false; }; "showFileList": { "alias": "showFileList"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "actionsLayout": { "alias": "actionsLayout"; "required": false; }; }, { "cancel": "cancel"; "clear": "clear"; "complete": "complete"; "error": "error"; "pause": "pause"; "resume": "resume"; "success": "success"; "upload": "upload"; "uploadProgress": "uploadProgress"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Represents the [Kendo UI FileSelect component for Angular](https://www.telerik.com/kendo-angular-ui/components/uploads/fileselect).
+ *
+ * @example
+ * ```html
+ * <kendo-fileselect> </kendo-fileselect>
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link CustomMessagesComponent}
+ */
+declare class FileSelectComponent extends UploadFileSelectBase implements OnInit, OnDestroy {
+    protected uploadService: UploadService;
+    private localization;
+    protected navigation: NavigationService;
+    private dropZoneService;
+    protected ngZone: NgZone;
+    private renderer;
+    protected cdr: ChangeDetectorRef;
+    protected injector: Injector;
+    fileSelectInput: ElementRef;
+    get dir(): string;
+    /**
+     * Specifies the `name` attribute of the `input` element of the FileSelect.
+     */
+    set name(name: string);
+    get name(): string;
+    /**
+     * Fires when the component value changes after a successful `select` or `remove` operation.
+     */
+    valueChange: EventEmitter<Array<File>>;
+    /**
+     * @hidden
+     */
+    _restrictions: FileRestrictions;
+    direction: Direction;
+    wrapper: HTMLElement;
+    fileListId: string;
+    private documentClick;
+    private blurSubscription;
+    private wrapperFocusSubscription;
+    private selectButtonFocusSubscription;
+    private localizationChangeSubscription;
+    private subs;
+    constructor(uploadService: UploadService, localization: LocalizationService, navigation: NavigationService, dropZoneService: DropZoneService, ngZone: NgZone, renderer: Renderer2, cdr: ChangeDetectorRef, wrapper: ElementRef, injector: Injector);
+    ngOnInit(): void;
+    /**
+     * @hidden
+     */
+    textFor(key: string): string;
+    ngOnDestroy(): void;
+    /**
+     * Removes a specific file from the file list.
+     *
+     * @param uid The `uid` of the file to be removed.
+     */
+    removeFileByUid(uid: string): void;
+    /**
+     * Clears all files from the UI.
+     */
+    clearFiles(): void;
+    /**
+     * @hidden
+     * Used to determine if the component is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * @hidden
+     * Used by the external dropzone to add files to the FileSelect
+     */
+    addFiles(files: FileInfo[]): void;
+    /**
+     * @hidden
+     */
+    get selectButtonTabIndex(): number;
+    /**
+     * @hidden
+     */
+    getIds(): {
+        buttonId: string;
+        fileListId: string;
+    };
+    /**
+     * @hidden
+     */
+    writeValue(newValue: any): void;
+    private subscribeBlur;
+    private subscribeFocus;
+    private handleKeydown;
+    private attachEventHandlers;
+    private setDefaultSettings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileSelectComponent, "kendo-fileselect", ["kendoFileSelect"], { "name": { "alias": "name"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class DropZoneService {
+    addComponent(component: UploadComponent | FileSelectComponent, zoneId: string): void;
+    clearComponent(component: UploadComponent | FileSelectComponent, zoneId: string): void;
+    getComponents(zoneId: string): Array<UploadComponent | FileSelectComponent>;
+    private has;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropZoneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropZoneService>;
+}
+
+/**
+ * @hidden
+ */
+declare class Messages extends ComponentMessages {
+    /**
+     * Sets the text for the **Cancel** button.
+     *
+     * @default 'Cancel'
+     */
+    cancel: string;
+    /**
+     * Sets the text for the **Clear** button.
+     *
+     * @default 'Clear'
+     */
+    clearSelectedFiles: string;
+    /**
+     * Sets the drop-zone hint.
+     *
+     * @default 'Drop files here to upload'
+     */
+    dropFilesHere: string;
+    /**
+     * Sets the external drop-zone hint.
+     *
+     * @default 'Drag and drop files here to upload'
+     */
+    externalDropFilesHere: string;
+    /**
+     * Sets the status message for a batch of files.
+     *
+     * @default 'files'
+     */
+    filesBatchStatus: string;
+    /**
+     * Sets the status message for a batch of files after failed upload.
+     *
+     * @default 'files failed to upload.'
+     */
+    filesBatchStatusFailed: string;
+    /**
+     * Sets the status message for a batch of files after successful upload.
+     *
+     * @default 'files successfully uploaded.'
+     */
+    filesBatchStatusUploaded: string;
+    /**
+     * Sets the file status message after failed upload.
+     *
+     * @default 'File failed to upload.'
+     */
+    fileStatusFailed: string;
+    /**
+     * Sets the file status message after successful upload.
+     *
+     * @default 'File successfully uploaded.'
+     */
+    fileStatusUploaded: string;
+    /**
+     * Sets the header status message when the file upload is paused.
+     *
+     * @default 'Paused'
+     */
+    headerStatusPaused: string;
+    /**
+     * Sets the header status message after the file upload completes.
+     *
+     * @default 'Done'
+     */
+    headerStatusUploaded: string;
+    /**
+     * Sets the header status message during the upload of the file.
+     *
+     * @default 'Uploading...'
+     */
+    headerStatusUploading: string;
+    /**
+     * Sets the text for the invalid `allowedExtensions` restriction message.
+     *
+     * @default 'File type not allowed.'
+     */
+    invalidFileExtension: string;
+    /**
+     * Sets the text for the invalid `maxFileSize` restriction message.
+     *
+     * @default 'File size too large.'
+     */
+    invalidMaxFileSize: string;
+    /**
+     * Sets the text for the invalid `minFileSize` restriction message.
+     *
+     * @default 'File size too small.'
+     */
+    invalidMinFileSize: string;
+    /**
+     * Sets the text for the **Pause** button.
+     *
+     * @default 'Pause'
+     */
+    pause: string;
+    /**
+     * Sets the text for the **Remove** button.
+     *
+     * @default 'Remove'
+     */
+    remove: string;
+    /**
+     * Sets the text for the **Resume** button.
+     *
+     * @default 'Resume'
+     */
+    resume: string;
+    /**
+     * Sets the text for the **Retry** button.
+     *
+     * @default 'Retry'
+     */
+    retry: string;
+    /**
+     * Sets the text for the **Select** button.
+     *
+     * @default 'Select files...'
+     */
+    select: string;
+    /**
+     * Sets the text for the **Upload files** button.
+     *
+     * @default 'Upload'
+     */
+    uploadSelectedFiles: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Messages, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Messages, never, never, { "cancel": { "alias": "cancel"; "required": false; }; "clearSelectedFiles": { "alias": "clearSelectedFiles"; "required": false; }; "dropFilesHere": { "alias": "dropFilesHere"; "required": false; }; "externalDropFilesHere": { "alias": "externalDropFilesHere"; "required": false; }; "filesBatchStatus": { "alias": "filesBatchStatus"; "required": false; }; "filesBatchStatusFailed": { "alias": "filesBatchStatusFailed"; "required": false; }; "filesBatchStatusUploaded": { "alias": "filesBatchStatusUploaded"; "required": false; }; "fileStatusFailed": { "alias": "fileStatusFailed"; "required": false; }; "fileStatusUploaded": { "alias": "fileStatusUploaded"; "required": false; }; "headerStatusPaused": { "alias": "headerStatusPaused"; "required": false; }; "headerStatusUploaded": { "alias": "headerStatusUploaded"; "required": false; }; "headerStatusUploading": { "alias": "headerStatusUploading"; "required": false; }; "invalidFileExtension": { "alias": "invalidFileExtension"; "required": false; }; "invalidMaxFileSize": { "alias": "invalidMaxFileSize"; "required": false; }; "invalidMinFileSize": { "alias": "invalidMinFileSize"; "required": false; }; "pause": { "alias": "pause"; "required": false; }; "remove": { "alias": "remove"; "required": false; }; "resume": { "alias": "resume"; "required": false; }; "retry": { "alias": "retry"; "required": false; }; "select": { "alias": "select"; "required": false; }; "uploadSelectedFiles": { "alias": "uploadSelectedFiles"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Custom component messages override default component messages ([more information and example](https://www.telerik.com/kendo-angular-ui/components/uploads/globalization)).
+ *
+ * @example
+ * ```html
+ * <!-- Custom messages for FileSelect -->
+ * <kendo-fileselect>
+ *     <kendo-fileselect-messages
+ *         dropFilesHere="Drop your file here"
+ *         select="Upload file">
+ *     </kendo-fileselect-messages>
+ * </kendo-fileselect>
+ *
+ * <!-- Custom messages for Upload -->
+ * <kendo-upload>
+ *     <kendo-upload-messages
+ *         dropFilesHere="Drop your file here"
+ *         fileStatusFailed="File upload failed"
+ *         fileStatusSuccessful="File upload successful">
+ *     </kendo-upload-messages>
+ * </kendo-upload>
+ *
+ * <!-- Custom messages for UploadDropZone -->
+ * <kendo-uploaddropzone>
+ *     <kendo-uploaddropzone-messages
+ *         externalDropFilesHere="Drag and your file here">
+ *     </kendo-uploaddropzone-messages>
+ * </kendo-uploaddropzone>
+ * ```
+ */
+declare class CustomMessagesComponent extends Messages {
+    protected service: LocalizationService;
+    protected get override(): boolean;
+    constructor(service: LocalizationService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomMessagesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CustomMessagesComponent, "kendo-upload-messages, kendo-fileselect-messages, kendo-uploaddropzone-messages", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [Kendo UI UploadDropZone directive for Angular](https://www.telerik.com/kendo-angular-ui/components/uploads).
+ * Use this directive to create external drop zones for Upload and FileSelect components.
+ *
+ * @example
+ * ```html
+ * <div kendoUploadDropZone="upload1">Drop files here</div>
+ * <kendo-upload [saveUrl]="uploadSaveUrl" zoneId="upload1"></kendo-upload>
+ * ```
+ */
+declare class UploadDropZoneDirective {
+    private dropZoneService;
+    /**
+     * The id of the drop zone to associate with an existing Upload component.
+     */
+    zoneId: string;
+    /**
+     * The id of the drop zone to associate with an existing FileSelect component.
+     */
+    fileSelectZoneId: string;
+    constructor(dropZoneService: DropZoneService);
+    /**
+     * @hidden
+     */
+    onElementDragEnter(): boolean;
+    /**
+     * @hidden
+     */
+    onElementDragOver(): boolean;
+    /**
+     * @hidden
+     */
+    onDropListener(event: any): boolean;
+    /**
+     * @hidden
+     */
+    get componentInstance(): Array<UploadComponent | FileSelectComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadDropZoneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UploadDropZoneDirective, "[kendoUploadDropZone], [kendoFileSelectDropZone]", never, { "zoneId": { "alias": "kendoUploadDropZone"; "required": false; }; "fileSelectZoneId": { "alias": "kendoFileSelectDropZone"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare abstract class DropZoneBase {
+    protected element: ElementRef;
+    protected renderer: Renderer2;
+    protected hoverClass: string;
+    protected lastDragElement: Date;
+    protected hideIntervalElement: any;
+    /**
+     * @hidden
+     */
+    onElementDragEnterListener(): boolean;
+    /**
+     * @hidden
+     */
+    onElementDragOverListener(): boolean;
+    constructor(element: ElementRef, renderer: Renderer2, cssClass: string);
+    protected calculateTimeDiff(prevEvent: Date): number;
+    protected addClass(className: string): void;
+    protected removeClass(className: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropZoneBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropZoneBase, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [Kendo UI UploadDropZone component for Angular](https://www.telerik.com/kendo-angular-ui/components/uploads).
+ *
+ * @example
+ * ```html
+ * <kendo-uploaddropzone zoneId="upload1">
+ *   Drop files here to upload
+ * </kendo-uploaddropzone>
+ * <kendo-upload [saveUrl]="uploadSaveUrl" zoneId="upload1"></kendo-upload>
+ * ```
+ *
+ * @remarks
+ * Supported children components are: {@link CustomMessagesComponent}
+ */
+declare class UploadDropZoneComponent extends DropZoneBase {
+    private localization;
+    hostClass: boolean;
+    get dirAttribute(): string;
+    /**
+     * Specifies the id of the component.
+     * Use this id to associate the DropZone with an existing Upload or FileSelect component.
+     */
+    zoneId: string;
+    /**
+     * Specifies the name for an existing icon in a Kendo UI theme.
+     * The icon renders inside the DropZone.
+     */
+    icon: string;
+    /**
+     * Specifies a CSS class or multiple classes separated by spaces which apply to a span element.
+     * Use this property to apply custom icons.
+     */
+    iconClass: string;
+    /**
+     * Specifies an SVGIcon to render inside the DropZone.
+     * The input accepts either an [existing Kendo SVG icon](https://www.telerik.com/kendo-angular-ui/components/icons/svgicon/svgicon-list) or a custom one.
+     */
+    set svgIcon(icon: SVGIcon);
+    get svgIcon(): SVGIcon;
+    private direction;
+    private localizationChangeSubscription;
+    private _svgIcon;
+    constructor(element: ElementRef, renderer: Renderer2, localization: LocalizationService);
+    /**
+     * @hidden
+     */
+    textFor(key: string): string;
+    /**
+     * @hidden
+     */
+    get iconClasses(): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadDropZoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadDropZoneComponent, "kendo-uploaddropzone", ["kendoUploadDropZone"], { "zoneId": { "alias": "zoneId"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Represents the [NgModule](https://angular.io/api/core/NgModule) definition for the FileSelect component.
+ */
+declare class FileSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FileSelectModule, never, [typeof FileSelectComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent], [typeof FileSelectComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FileSelectModule>;
+}
+
+/**
+ * @hidden
+ */
+declare class UploadActionButtonsComponent {
+    private uploadService;
+    private localization;
+    private navigation;
+    disabled: boolean;
+    actionsLayout: ActionsLayout;
+    clearButton: ElementRef;
+    uploadButton: ElementRef;
+    hostDefaultClass: boolean;
+    hostHorizontalClass: boolean;
+    get actionButtonsEndClassName(): boolean;
+    get actionButtonsStretchedClassName(): boolean;
+    get actionButtonsStartClassName(): boolean;
+    get actionButtonsCenterClassName(): boolean;
+    constructor(uploadService: UploadService, localization: LocalizationService, navigation: NavigationService);
+    onUploadButtonFocus(): void;
+    onUploadButtonClick(event?: any): void;
+    performUpload(): void;
+    onClearButtonClick(event?: any): void;
+    clearFiles(): void;
+    textFor(key: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadActionButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadActionButtonsComponent, "kendo-upload-action-buttons", never, { "disabled": { "alias": "disabled"; "required": false; }; "actionsLayout": { "alias": "actionsLayout"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class UploadStatusTotalComponent implements DoCheck {
+    private localization;
+    fileList: FileMap;
+    isFailed: boolean;
+    isPaused: boolean;
+    isUploading: boolean;
+    statusText: string;
+    checkmarkIcon: SVGIcon;
+    exceptionSVGIcon: SVGIcon;
+    uploadSVGIcon: SVGIcon;
+    pauseSVGIcon: SVGIcon;
+    constructor(localization: LocalizationService);
+    get iconClass(): string;
+    get SVGIconClass(): SVGIcon;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadStatusTotalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadStatusTotalComponent, "kendo-upload-status-total", never, { "fileList": { "alias": "fileList"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents the [NgModule](https://angular.io/api/core/NgModule) definition for the Upload component.
+ */
+declare class UploadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UploadModule, never, [typeof UploadComponent, typeof UploadActionButtonsComponent, typeof UploadStatusTotalComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent], [typeof UploadComponent, typeof UploadActionButtonsComponent, typeof UploadStatusTotalComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UploadModule>;
+}
+
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi'])
+ * definition for the Uploads components.
+ *
+ * @example
+ *
+ * ```ts-no-run
+ * import { UploadsModule } from '@progress/kendo-angular-upload';
+ *
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ * import { NgModule } from '@angular/core';
+ *
+ * import { AppComponent } from './app.component';
+ *
+ * _@NgModule({
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, UploadsModule],
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ *
+ * platformBrowserDynamic().bootstrapModule(AppModule);
+ *
+ * ```
+ */
+declare class UploadsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UploadsModule, never, [typeof FileSelectComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent, typeof UploadComponent, typeof UploadActionButtonsComponent, typeof UploadStatusTotalComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent], [typeof FileSelectComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent, typeof UploadComponent, typeof UploadActionButtonsComponent, typeof UploadStatusTotalComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UploadsModule>;
+}
+
+/**
+ * @hidden
+ */
+declare class FileSelectDirective {
+    private uploadService;
+    private navigation;
+    dir: Direction;
+    disabled: boolean;
+    multiple: boolean;
+    restrictions: FileRestrictions;
+    accept: string;
+    required: boolean;
+    type: string;
+    autocomplete: string;
+    tabIndex: number;
+    ariaHidden: boolean;
+    element: ElementRef;
+    constructor(uploadService: UploadService, navigation: NavigationService, el: ElementRef);
+    classNames: boolean;
+    get nameAttribute(): string;
+    get multipleAttribute(): string;
+    get dirAttribute(): string;
+    get disabledAttribute(): string;
+    get acceptAttribute(): string;
+    get requiredAttribute(): string;
+    onInputChange(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileSelectDirective, "[kendoFileSelect]", never, { "dir": { "alias": "dir"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "restrictions": { "alias": "restrictions"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class FileListItemDirective {
+    private navigationService;
+    private uploadService;
+    files: Array<FileInfo>;
+    index: number;
+    fileClass: boolean;
+    focused: boolean;
+    element: ElementRef;
+    constructor(el: ElementRef, navigationService: NavigationService, uploadService: UploadService);
+    focus(): void;
+    get uidAttribute(): string;
+    get tabIndex(): string;
+    get kFileError(): boolean;
+    get kFileInvalid(): boolean;
+    get kFileProgress(): boolean;
+    get kFileSuccess(): boolean;
+    get kStateFocused(): boolean;
+    onFocus(): void;
+    onBlur(): void;
+    onClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileListItemDirective, "[kendoUploadFileListItem]", never, { "files": { "alias": "files"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class FileListComponent implements OnDestroy {
+    private uploadService;
+    private navigation;
+    disabled: boolean;
+    fileList: Array<Array<FileInfo>>;
+    fileTemplate: FileTemplateDirective;
+    fileInfoTemplate: FileInfoTemplateDirective;
+    fileListItems: QueryList<FileListItemDirective>;
+    fileListRole: string;
+    private focusSubscription;
+    private actionSubscription;
+    constructor(uploadService: UploadService, navigation: NavigationService);
+    onItemFocus(): void;
+    onItemAction(): void;
+    itemActionHandler(key: string): void;
+    hasDelete(item: FileListItemDirective): boolean;
+    /**
+     * Tracks files array by the UID of the first file in the batch.
+     * Each batch of files shares the same UID, which remains stable
+     * throughout the file lifecycle until the batch is removed.
+     */
+    trackByUid(index: number, files: Array<FileInfo>): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileListComponent, "[kendo-upload-file-list]", never, { "disabled": { "alias": "disabled"; "required": false; }; "fileList": { "alias": "fileList"; "required": false; }; "fileTemplate": { "alias": "fileTemplate"; "required": false; }; "fileInfoTemplate": { "alias": "fileInfoTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class FileListItemBase implements OnDestroy {
+    protected uploadService: UploadService;
+    protected cdr: ChangeDetectorRef;
+    progressComplete: number;
+    protected localization: LocalizationService;
+    protected uploadProgressSubscription: Subscription;
+    constructor(uploadService: UploadService, cdr: ChangeDetectorRef);
+    protected subscribeUploadProgress(uploadProgressHandler: (args: UploadProgressEvent) => void): void;
+    protected fileHasValidationErrors(file: FileInfo): boolean;
+    protected filesHaveValidationErrors(files: Array<FileInfo>): boolean;
+    ngOnDestroy(): void;
+    getFileValidationMessage(file: FileInfo): string;
+    getTotalFilesSizeMessage(files: Array<FileInfo>): string;
+    textFor(key: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileListItemBase, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileListItemBase, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class FileListSingleItemComponent extends FileListItemBase {
+    protected localization: LocalizationService;
+    disabled: boolean;
+    file: FileInfo;
+    fileInfoTemplate: FileInfoTemplateDirective;
+    constructor(localization: LocalizationService, uploadService: UploadService, cdr: ChangeDetectorRef);
+    get fileStatusText(): string;
+    get showProgress(): string;
+    get fileGroupClass(): string;
+    get fileSVGGroupIcon(): SVGIcon;
+    get isUploadSuccessful(): boolean;
+    get isUploadFailed(): boolean;
+    get isNotYetUploaded(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileListSingleItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileListSingleItemComponent, "kendo-upload-file-list-single-item", never, { "disabled": { "alias": "disabled"; "required": false; }; "file": { "alias": "file"; "required": false; }; "fileInfoTemplate": { "alias": "fileInfoTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class FileListItemActionButtonComponent {
+    private uploadService;
+    private localization;
+    private navigation;
+    file: FileInfo;
+    disabled: boolean;
+    progress: number;
+    retrySVGIcon: SVGIcon;
+    playSVGIcon: SVGIcon;
+    pauseSVGIcon: SVGIcon;
+    cancelSVGIcon: SVGIcon;
+    deleteSVGIcon: SVGIcon;
+    constructor(uploadService: UploadService, localization: LocalizationService, navigation: NavigationService);
+    onRetryClick(): void;
+    onRemoveCancelClick(event?: any): void;
+    onPauseResumeClick(): void;
+    get actionButtonTitle(): string;
+    get retryButtonTitle(): string;
+    get pauseResumeButtonTitle(): string;
+    get isUploading(): boolean;
+    get isFailed(): boolean;
+    get isPaused(): boolean;
+    get isResumable(): boolean;
+    get isActionButtonVisible(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileListItemActionButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileListItemActionButtonComponent, "kendo-upload-file-list-item-action-button", never, { "file": { "alias": "file"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare class FileListMultipleItemsComponent extends FileListItemBase implements OnInit {
+    protected localization: LocalizationService;
+    disabled: boolean;
+    files: Array<FileInfo>;
+    fileInfoTemplate: FileInfoTemplateDirective;
+    filesHaveErrors: boolean;
+    copySVGIcon: SVGIcon;
+    constructor(localization: LocalizationService, uploadService: UploadService, cdr: ChangeDetectorRef);
+    get showProgress(): string;
+    ngOnInit(): void;
+    fileStatusText(file: FileInfo): any;
+    get batchStatusText(): string;
+    get isUploadSuccessful(): boolean;
+    get isUploadFailed(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileListMultipleItemsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileListMultipleItemsComponent, "kendo-upload-file-list-multiple-items", never, { "disabled": { "alias": "disabled"; "required": false; }; "files": { "alias": "files"; "required": false; }; "fileInfoTemplate": { "alias": "fileInfoTemplate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @hidden
+ */
+declare const validateFiles: Function;
+
+/**
+ * Calculates the total size of the files in KB or MB.
+ */
+declare const getTotalFilesSizeMessage: Function;
+/**
+ * Matches the file extension with the corresponding SVG icon.
+ * @returns The SVG icon that corresponds to the file extension.
+ */
+declare const fileSVGGroupIcon: (extension: string) => SVGIcon$1;
+/**
+ * Matches the file extension with the corresponding CSS class.
+ * @returns The CSS class name that corresponds to the file extension.
+ */
+declare const fileGroupClass: (extension: string) => string;
+
+/**
+ * Defines the settings interface for the FileSelect functionality used in components that integrate the FileSelect component.
+ *
+ * @example
+ * ```typescript
+ * const fileSelectSettings: FileSelectSettings = {
+ *   multiple: true,
+ *   disabled: false
+ * };
+ * ```
+ */
+interface FileSelectSettings {
+    /**
+     * Sets the `accept` attribute of the internal `input` element of the component.
+     */
+    accept?: string;
+    /**
+     * Disables the component.
+     */
+    disabled?: boolean;
+    /**
+     * Allows you to select multiple files. When you set this to `false`, you can select only one file at a time.
+     */
+    multiple?: boolean;
+    /**
+     * Specifies the `name` attribute of the `input` element of the FileSelect.
+     */
+    name?: string;
+    /**
+     * Sets the restrictions for selected files.
+     */
+    restrictions?: FileRestrictions;
+    /**
+     * Controls the visibility of the file list.
+     */
+    showFileList?: boolean;
+    /**
+     * Sets the `tabindex` of the component.
+     */
+    tabindex?: number;
+    /**
+     * Sets the `id` of the external drop zone that you want to associate with the component.
+     */
+    zoneId?: string;
+}
+
+/**
+ * Use the `KENDO_FILESELECT` utility array to add all FileSelect-related components and directives to a standalone Angular component.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_FILESELECT } from '@progress/kendo-angular-upload';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   standalone: true,
+ *   imports: [KENDO_FILESELECT],
+ *   template: `<kendo-fileselect></kendo-fileselect>`
+ * })
+ * export class AppComponent {}
+ * ```
+ */
+declare const KENDO_FILESELECT: readonly [typeof FileSelectComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent];
+/**
+ * Use the `KENDO_UPLOAD` utility array to add all Upload-related components and directives to a standalone Angular component.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_UPLOAD } from '@progress/kendo-angular-upload';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   standalone: true,
+ *   imports: [KENDO_UPLOAD],
+ *   template: `<kendo-upload></kendo-upload>`
+ * })
+ * export class AppComponent {}
+ * ```
+ */
+declare const KENDO_UPLOAD: readonly [typeof UploadComponent, typeof UploadActionButtonsComponent, typeof UploadStatusTotalComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent];
+/**
+ * Use the `KENDO_UPLOADS` utility array to add all `@progress/kendo-angular-upload`-related components and directives to a standalone Angular component.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_UPLOADS } from '@progress/kendo-angular-upload';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   standalone: true,
+ *   imports: [KENDO_UPLOADS],
+ *   template: `
+ *      <kendo-upload></kendo-upload>
+ *      <kendo-fileselect></kendo-fileselect>
+ *   `
+ * })
+ * export class AppComponent {}
+ * ```
+ */
+declare const KENDO_UPLOADS: readonly [typeof FileSelectComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent, typeof UploadComponent, typeof UploadActionButtonsComponent, typeof UploadStatusTotalComponent, typeof FileTemplateDirective, typeof FileInfoTemplateDirective, typeof CustomMessagesComponent, typeof UploadDropZoneDirective, typeof UploadDropZoneComponent];
+
+export { CancelEvent, ClearEvent, CustomMessagesComponent, DropZoneService, ErrorEvent, FileInfoTemplateDirective, FileListComponent, FileListItemActionButtonComponent, FileListItemBase, FileListMultipleItemsComponent, FileListSingleItemComponent, FileMap, FileSelectComponent, FileSelectDirective, FileSelectModule, FileState, FileTemplateDirective, KENDO_FILESELECT, KENDO_UPLOAD, KENDO_UPLOADS, NavigationService, PauseEvent, RemoveEvent, ResumeEvent, SelectEvent, SuccessEvent, UPLOAD_VALUE_ACCESSOR, UploadActionButtonsComponent, UploadComponent, UploadDropZoneComponent, UploadDropZoneDirective, UploadEvent, UploadModule, UploadProgressEvent, UploadService, UploadStatusTotalComponent, UploadsModule, fileGroupClass, fileSVGGroupIcon, getTotalFilesSizeMessage, validateFiles };
+export type { ActionsLayout, ChunkMetadata, ChunkSettings, FileInfo, FileRestrictions, FileSelectSettings, OperationType };