import * as i0 from '@angular/core';
import { EventEmitter, ElementRef } from '@angular/core';

declare class FileLikeObject {
    lastModifiedDate: any;
    size: any;
    type?: string;
    name?: string;
    rawFile: HTMLInputElement | File;
    constructor(fileOrInput: HTMLInputElement | File);
    _createFromFakePath(path: string): void;
    _createFromObject(object: {
        size: number;
        type: string;
        name: string;
    }): void;
}

declare class FileItem {
    file: FileLikeObject;
    _file: File;
    alias?: string;
    url: string;
    method?: string;
    headers: any;
    withCredentials: boolean;
    formData: any;
    isReady: boolean;
    isUploading: boolean;
    isUploaded: boolean;
    isSuccess: boolean;
    isCancel: boolean;
    isError: boolean;
    progress: number;
    index?: number;
    _xhr?: XMLHttpRequest;
    _form: any;
    protected uploader: FileUploader;
    protected some: File;
    protected options: FileUploaderOptions;
    constructor(uploader: FileUploader, some: File, options: FileUploaderOptions);
    upload(): void;
    cancel(): void;
    remove(): void;
    onBeforeUpload(): void;
    onBuildForm(form: any): any;
    onProgress(progress: number): any;
    onSuccess(response: string, status: number, headers: ParsedResponseHeaders): any;
    onError(response: string, status: number, headers: ParsedResponseHeaders): any;
    onCancel(response: string, status: number, headers: ParsedResponseHeaders): any;
    onComplete(response: string, status: number, headers: ParsedResponseHeaders): any;
    _onBeforeUpload(): void;
    _onBuildForm(form: any): void;
    _onProgress(progress: number): void;
    _onSuccess(response: string, status: number, headers: ParsedResponseHeaders): void;
    _onError(response: string, status: number, headers: ParsedResponseHeaders): void;
    _onCancel(response: string, status: number, headers: ParsedResponseHeaders): void;
    _onComplete(response: string, status: number, headers: ParsedResponseHeaders): void;
    _prepareToUploading(): void;
}

interface Headers {
    name: string;
    value: string;
}
interface ParsedResponseHeaders {
    [headerFieldName: string]: string;
}
interface FilterFunction {
    name: string;
    fn(item: FileLikeObject, options?: FileUploaderOptions): boolean;
}
interface FileUploaderOptions {
    allowedMimeType?: string[];
    allowEmptyMimeType?: boolean;
    allowedFileType?: string[];
    autoUpload?: boolean;
    isHTML5?: boolean;
    filters?: FilterFunction[];
    headers?: Headers[];
    method?: string;
    authToken?: string;
    maxFileSize?: number;
    queueLimit?: number;
    removeAfterUpload?: boolean;
    url: string;
    disableMultipart?: boolean;
    itemAlias?: string;
    authTokenHeader?: string;
    additionalParameter?: {
        [key: string]: any;
    };
    parametersBeforeFiles?: boolean;
    formatDataFunction?: Function;
    formatDataFunctionIsAsync?: boolean;
}
declare class FileUploader {
    authToken?: string;
    isUploading: boolean;
    queue: FileItem[];
    progress: number;
    _nextIndex: number;
    autoUpload: any;
    authTokenHeader?: string;
    response: EventEmitter<any>;
    options: FileUploaderOptions;
    protected _failFilterIndex?: number;
    constructor(options: FileUploaderOptions);
    setOptions(options: FileUploaderOptions): void;
    addToQueue(files: File[] | FileList, _options?: FileUploaderOptions, filters?: [] | string): void;
    removeFromQueue(value: FileItem): void;
    clearQueue(): void;
    uploadItem(value: FileItem): void;
    cancelItem(value: FileItem): void;
    uploadAll(): void;
    cancelAll(): void;
    isFile(value: any): boolean;
    isFileLikeObject(value: any): boolean;
    getIndexOfItem(value: any): number;
    getNotUploadedItems(): any[];
    getReadyItems(): any[];
    onAfterAddingAll(fileItems: any): any;
    onBuildItemForm(fileItem: FileItem, form: any): any;
    onAfterAddingFile(fileItem: FileItem): any;
    onWhenAddingFileFailed(item: FileLikeObject, filter: any, options: any): any;
    onBeforeUploadItem(fileItem: FileItem): any;
    onProgressItem(fileItem: FileItem, progress: any): any;
    onProgressAll(progress: any): any;
    onSuccessItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any;
    onErrorItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any;
    onCancelItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any;
    onCompleteItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any;
    onCompleteAll(): any;
    _mimeTypeFilter(item: FileLikeObject): boolean;
    _fileSizeFilter(item: FileLikeObject): boolean;
    _fileTypeFilter(item: FileLikeObject): boolean;
    _onErrorItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void;
    _onCompleteItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void;
    protected _finishItem(item: FileItem, method: '_onSuccessItem' | '_onErrorItem' | '_onCancelItem', response: string, status: number, headers: ParsedResponseHeaders): void;
    private _uploadNext;
    protected _headersGetter(parsedHeaders: ParsedResponseHeaders): any;
    protected _xhrTransport(item: FileItem): any;
    protected _buildFormData(item: FileItem, file: Blob, extraParameters?: {
        [key: string]: string;
    }): FormData;
    protected _openRequest(xhr: XMLHttpRequest, item: FileItem): void;
    protected _getTotalProgress(value?: number): number;
    protected _getFilters(filters?: FilterFunction[] | string): FilterFunction[] | [];
    protected _render(): any;
    protected _queueLimitFilter(): boolean;
    protected _isValidFile(file: FileLikeObject, filters: FilterFunction[], options: FileUploaderOptions): boolean;
    protected _isSuccessCode(status: number): boolean;
    protected _transformResponse(response: string): string;
    protected _parseHeaders(headers: string): ParsedResponseHeaders;
    protected _onWhenAddingFileFailed(item: FileLikeObject, filter: any, options: any): void;
    protected _onAfterAddingFile(item: FileItem): void;
    protected _onAfterAddingAll(items: any): void;
    protected _onBeforeUploadItem(item: FileItem): void;
    protected _onBuildItemForm(item: FileItem, form: any): void;
    protected _onProgressItem(item: FileItem, progress: any): void;
    protected _onSuccessItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void;
    protected _onCancelItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void;
}

interface ChunkedFileUploaderOptions extends FileUploaderOptions {
    chunkSize?: number;
    chunkIndexParam?: string;
    totalChunksParam?: string;
}
interface FileChunk {
    index: number;
    total: number;
    start: number;
    end: number;
    blob: Blob;
}
declare class ChunkedFileUploader extends FileUploader {
    options: ChunkedFileUploaderOptions;
    private _chunks;
    constructor(options: ChunkedFileUploaderOptions);
    setOptions(options: ChunkedFileUploaderOptions): void;
    getChunk(item: FileItem): FileChunk | undefined;
    resumeItem(item: FileItem): void;
    resumeAll(): void;
    _onErrorItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void;
    cancelItem(value: FileItem): void;
    onBeforeUploadChunk(item: FileItem, chunk: FileChunk): any;
    onSuccessChunk(item: FileItem, chunk: FileChunk, response: string, status: number, headers: ParsedResponseHeaders): any;
    onErrorChunk(item: FileItem, chunk: FileChunk, response: string, status: number, headers: ParsedResponseHeaders): any;
    protected _xhrTransport(item: FileItem): any;
    protected _onCancelItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void;
    protected _getTotalProgress(value?: number): number;
    private _setResumePoint;
    private _keepProgress;
    private _sliceChunk;
    private _sendChunk;
    private _onChunkDone;
    private _runChunkHook;
}

declare class FileSelectDirective {
    readonly uploader: i0.InputSignal<FileUploader | undefined>;
    readonly onFileSelected: i0.OutputEmitterRef<FileList>;
    protected element: ElementRef<any>;
    getOptions(): FileUploaderOptions | undefined;
    getFilters(): string;
    isEmptyAfterSelection(): boolean;
    onClick(): void;
    onChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileSelectDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FileSelectDirective, "[ng2FileSelect]", never, { "uploader": { "alias": "uploader"; "required": false; "isSignal": true; }; }, { "onFileSelected": "onFileSelected"; }, never, never, true, never>;
}

declare class FileDropDirective {
    readonly uploader: i0.InputSignal<FileUploader | undefined>;
    readonly fileOver: i0.OutputEmitterRef<boolean>;
    readonly onFileDrop: i0.OutputEmitterRef<FileList>;
    protected readonly element: ElementRef<any>;
    getOptions(): FileUploaderOptions | void;
    getFilters(): string;
    onDrop(event: MouseEvent): void;
    onDragOver(event: MouseEvent): void;
    onDragLeave(event: MouseEvent): void;
    protected _getTransfer(event: any): DataTransfer;
    protected _preventAndStop(event: MouseEvent): void;
    protected _haveFiles(types: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileDropDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FileDropDirective, "[ng2FileDrop]", never, { "uploader": { "alias": "uploader"; "required": false; "isSignal": true; }; }, { "fileOver": "fileOver"; "onFileDrop": "onFileDrop"; }, never, never, true, never>;
}

declare class FileUploadModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FileUploadModule, never, [typeof FileSelectDirective, typeof FileDropDirective], [typeof FileSelectDirective, typeof FileDropDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FileUploadModule>;
}

export { ChunkedFileUploader, FileDropDirective, FileItem, FileLikeObject, FileSelectDirective, FileUploadModule, FileUploader };
export type { ChunkedFileUploaderOptions, FileChunk, FileUploaderOptions, FilterFunction, Headers, ParsedResponseHeaders };