ng2-file-upload

constructor(options: ChunkedFileUploaderOptions);

options: ChunkedFileUploaderOptions;

cancelItem: (value: FileItem) => void;

getChunk: (item: FileItem) => FileChunk | undefined;

onBeforeUploadChunk: (item: FileItem, chunk: FileChunk) => any;

onErrorChunk: (
    item: FileItem,
    chunk: FileChunk,
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

onSuccessChunk: (
    item: FileItem,
    chunk: FileChunk,
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

resumeAll: () => void;

resumeItem: (item: FileItem) => void;

setOptions: (options: ChunkedFileUploaderOptions) => void;

protected readonly element: ElementRef<any>;

readonly fileOver: i0.OutputEmitterRef<boolean>;

readonly onFileDrop: i0.OutputEmitterRef<FileList>;

static ɵdir: i0.ɵɵDirectiveDeclaration<
    FileDropDirective,
    '[ng2FileDrop]',
    never,
    { uploader: { alias: 'uploader'; required: false; isSignal: true } },
    { fileOver: 'fileOver'; onFileDrop: 'onFileDrop' },
    never,
    never,
    true,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<FileDropDirective, never>;

readonly uploader: i0.InputSignal<FileUploader>;

getFilters: () => string;

getOptions: () => FileUploaderOptions | void;

onDragLeave: (event: MouseEvent) => void;

onDragOver: (event: MouseEvent) => void;

onDrop: (event: MouseEvent) => void;

constructor(uploader: FileUploader, some: File, options: FileUploaderOptions);

alias?: string;

file: FileLikeObject;

formData: any;

headers: any;

index?: number;

isCancel: boolean;

isError: boolean;

isReady: boolean;

isSuccess: boolean;

isUploaded: boolean;

isUploading: boolean;

method?: string;

protected options: FileUploaderOptions;

progress: number;

protected some: File;

protected uploader: FileUploader;

url: string;

withCredentials: boolean;

cancel: () => void;

onBeforeUpload: () => void;

onBuildForm: (form: any) => any;

onCancel: (
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

onComplete: (
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

onError: (
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

onProgress: (progress: number) => any;

onSuccess: (
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

remove: () => void;

upload: () => void;

constructor(fileOrInput: File | HTMLInputElement);

lastModifiedDate: any;

name?: string;

rawFile: File | HTMLInputElement;

size: any;

type?: string;

protected element: ElementRef<any>;

readonly onFileSelected: i0.OutputEmitterRef<FileList>;

static ɵdir: i0.ɵɵDirectiveDeclaration<
    FileSelectDirective,
    '[ng2FileSelect]',
    never,
    { uploader: { alias: 'uploader'; required: false; isSignal: true } },
    { onFileSelected: 'onFileSelected' },
    never,
    never,
    true,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<FileSelectDirective, never>;

readonly uploader: i0.InputSignal<FileUploader>;

getFilters: () => string;

getOptions: () => FileUploaderOptions | undefined;

isEmptyAfterSelection: () => boolean;

onChange: () => void;

onClick: () => void;

constructor(options: FileUploaderOptions);

authToken?: string;

authTokenHeader?: string;

autoUpload: any;

isUploading: boolean;

options: FileUploaderOptions;

progress: number;

queue: FileItem[];

response: EventEmitter<any>;

addToQueue: (
    files: File[] | FileList,
    _options?: FileUploaderOptions,
    filters?: [] | string
) => void;

cancelAll: () => void;

cancelItem: (value: FileItem) => void;

clearQueue: () => void;

getIndexOfItem: (value: any) => number;

getNotUploadedItems: () => any[];

getReadyItems: () => any[];

isFile: (value: any) => boolean;

isFileLikeObject: (value: any) => boolean;

onAfterAddingAll: (fileItems: any) => any;

onAfterAddingFile: (fileItem: FileItem) => any;

onBeforeUploadItem: (fileItem: FileItem) => any;

onBuildItemForm: (fileItem: FileItem, form: any) => any;

onCancelItem: (
    item: FileItem,
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

onCompleteAll: () => any;

onCompleteItem: (
    item: FileItem,
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

onErrorItem: (
    item: FileItem,
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

onProgressAll: (progress: any) => any;

onProgressItem: (fileItem: FileItem, progress: any) => any;

onSuccessItem: (
    item: FileItem,
    response: string,
    status: number,
    headers: ParsedResponseHeaders
) => any;

onWhenAddingFileFailed: (item: FileLikeObject, filter: any, options: any) => any;

removeFromQueue: (value: FileItem) => void;

setOptions: (options: FileUploaderOptions) => void;

uploadAll: () => void;

uploadItem: (value: FileItem) => void;

static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadModule, never>;

static ɵinj: i0.ɵɵInjectorDeclaration<FileUploadModule>;

static ɵmod: i0.ɵɵNgModuleDeclaration<
    FileUploadModule,
    never,
    [typeof FileSelectDirective, typeof FileDropDirective],
    [typeof FileSelectDirective, typeof FileDropDirective]
>;

chunkIndexParam?: string;

chunkSize?: number;

totalChunksParam?: string;

blob: Blob;

end: number;

index: number;

start: number;

total: number;

additionalParameter?: {
    [key: string]: any;
};

allowedFileType?: string[];

allowedMimeType?: string[];

allowEmptyMimeType?: boolean;

authToken?: string;

authTokenHeader?: string;

autoUpload?: boolean;

disableMultipart?: boolean;

filters?: FilterFunction[];

formatDataFunction?: Function;

formatDataFunctionIsAsync?: boolean;

headers?: Headers[];

isHTML5?: boolean;

itemAlias?: string;

maxFileSize?: number;

method?: string;

parametersBeforeFiles?: boolean;

queueLimit?: number;

removeAfterUpload?: boolean;

url: string;

name: string;

fn: (item: FileLikeObject, options?: FileUploaderOptions) => boolean;

name: string;

value: string;

[headerFieldName: string]: string;