import * as _angular_core from '@angular/core';
import { OnInit, OnDestroy, TemplateRef } from '@angular/core';
import { AXEvent } from '@acorex/cdk/common';
import * as rxjs from 'rxjs';
import { Subject, BehaviorSubject } from 'rxjs';

/**
 * A directive that provides browse functionality for file uploads.
 * When applied to an element, clicking it will trigger the file browser dialog.
 * @category Directives
 */
declare class AXUploaderBrowseDirective implements OnInit, OnDestroy {
    /**
     * The uploader zone directive instance.
     * @ignore
     */
    private uploaderZone;
    /**
     * The element reference for the directive host.
     * @ignore
     */
    private elementRef;
    /**
     * Platform ID for browser detection.
     * @ignore
     */
    private platformID;
    /**
     * Initializes the directive by adding click event listener and data attribute.
     */
    ngOnInit(): void;
    /**
     * Cleans up the directive by removing event listeners.
     */
    ngOnDestroy(): void;
    /**
     * Handles the click event to trigger file browser.
     * @private
     */
    private handleClick;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXUploaderBrowseDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXUploaderBrowseDirective, "[axUploaderBrowseHandle]", never, {}, {}, never, never, true, never>;
}

type AXUploadStatus = 'new' | 'inprogress' | 'completed' | 'failed' | 'canceled';
interface AXUploaderChangedEvent extends AXEvent {
    requests: AXUploadRequest[];
}
interface AXUploaderFileStartEvent extends AXEvent {
    uploadedFile: AXUploadRequest;
}
interface AXUploaderFileCompleteEvent extends AXEvent {
    uploadedFile: AXUploadRequest;
}
interface AXUploaderFilesCompleteEvent extends AXEvent {
    uploadedFiles: AXUploadRequest[];
    data?: any;
}
interface AXUploaderFileCancelEvent extends AXEvent {
    uploadedFile: AXUploadRequest;
}
declare class AXUploadRequest {
    private uploadFile;
    get name(): string;
    get ext(): string;
    get size(): number;
    get file(): File;
    private readonly _progress;
    progress: _angular_core.Signal<number>;
    private readonly _estimateTime;
    estimateTime: _angular_core.Signal<number>;
    private readonly _status;
    status: _angular_core.Signal<AXUploadStatus>;
    private readonly _message;
    message: _angular_core.Signal<string>;
    private readonly _isDetermined;
    isDetermined: _angular_core.Signal<boolean>;
    private startTime;
    private bytesTransferred;
    metaData: any;
    onCancel: Subject<void>;
    onStart: Subject<void>;
    onFailed: Subject<void>;
    onComplete: BehaviorSubject<void>;
    constructor(uploadFile: File);
    private estimateTimeRemaining;
    setTransferredBytes(value: number): void;
    private updateEstimateTime;
    upload(): Promise<void>;
    cancel(): void;
    redo(): void;
    error(message: string): void;
    finish(data?: any): void;
}

/**
 * A directive that provides drag-and-drop and file upload functionality.
 * When applied to an element, it enables drag-and-drop file uploads and file browsing.
 * @category Directives
 */
declare class AXUploaderZoneDirective implements OnDestroy {
    /**
     * The element reference for the directive host.
     * @ignore
     */
    private elementRef;
    /**
     * View container reference for rendering custom templates.
     * @ignore
     */
    private viewContainerRef;
    /**
     * Whether multiple files can be selected.
     * @defaultValue true
     */
    multiple: _angular_core.InputSignal<boolean>;
    /**
     * File types that are accepted for upload.
     * @defaultValue null
     */
    accept: _angular_core.InputSignal<string>;
    /**
     * Custom template for the drag overlay. If provided, this will be used instead of the default overlay.
     */
    overlayTemplate: _angular_core.InputSignal<TemplateRef<unknown>>;
    /**
     * Whether browsing files by clicking on the container is disabled.
     * @defaultValue false
     */
    disableBrowse: _angular_core.InputSignal<boolean>;
    /**
     * Whether drag and drop functionality is disabled.
     * @defaultValue false
     */
    disableDragDrop: _angular_core.InputSignal<boolean>;
    /**
     * Change detector reference.
     * @ignore
     */
    private cdr;
    /**
     * Document reference.
     * @ignore
     */
    private document;
    /**
     * Platform ID for browser detection.
     * @ignore
     */
    private platformID;
    /**
     * Upload service instance.
     * @ignore
     */
    private uploadService;
    /**
     * Unsubscriber service instance.
     * @ignore
     */
    private unsubscriber;
    /**
     * Translation service instance.
     * @ignore
     */
    private translateService;
    /**
     * The host element.
     * @ignore
     */
    private element;
    /**
     * Embedded view reference for custom template.
     * @ignore
     */
    private templateViewRef;
    /**
     * Emitted when files are selected or dropped (like HTML file input).
     * Emits an event with files property containing the selected files.
     */
    fileChange: _angular_core.OutputEmitterRef<{
        event: Event;
        files: File[];
    }>;
    /**
     * Emitted when files are changed (added, removed, etc.).
     * @deprecated Use fileChange instead for simpler file input-like behavior
     */
    onChanged: _angular_core.OutputEmitterRef<AXUploaderChangedEvent>;
    /**
     * Emitted on drag enter event.
     */
    dragEnter: _angular_core.OutputEmitterRef<DragEvent>;
    /**
     * Emitted on drag leave event.
     */
    dragLeave: _angular_core.OutputEmitterRef<DragEvent>;
    /**
     * Emitted on drag over event.
     */
    dragOver: _angular_core.OutputEmitterRef<DragEvent>;
    /**
     * Emitted when a single file upload is completed.
     */
    onFileUploadComplete: _angular_core.OutputEmitterRef<AXUploaderFileCompleteEvent>;
    /**
     * Emitted when all files upload is completed.
     */
    onFilesUploadComplete: _angular_core.OutputEmitterRef<AXUploaderFilesCompleteEvent>;
    /**
     * CSS class for the overlay state.
     * @ignore
     */
    stateClass: string;
    /**
     * The overlay element for drag and drop visual feedback.
     * @ignore
     */
    overlayElement: HTMLDivElement | null;
    /**
     * Flag to track if dragOver has been emitted for the current drag session.
     * @ignore
     */
    private dragOverEmitted;
    /**
     * Counter to track drag enter/leave depth to prevent false dragleave events.
     * When moving from parent to child, dragleave fires even though we're still inside.
     * @ignore
     */
    private dragDepth;
    /**
     * Animation end handler for cleanup.
     * @ignore
     */
    private animationEndHandler;
    /**
     * Initializes the directive with event listeners and service subscriptions.
     */
    constructor();
    /**
     * Cleans up event listeners when the directive is destroyed.
     */
    ngOnDestroy(): void;
    /**
     * Handles drag enter events to show the upload overlay.
     * @private
     */
    private handleDragEnter;
    /**
     * Handles drop events to process dropped files.
     * @private
     */
    private handleOnDrop;
    /**
     * Handles drag over events to allow dropping.
     * @private
     */
    private handleDragOver;
    /**
     * Creates the visual overlay for drag and drop feedback.
     * @private
     */
    private createZone;
    /**
     * Cancels any pending exit animation and cleans up handlers.
     * @private
     */
    private cancelExitAnimation;
    /**
     * Removes the visual overlay for drag and drop feedback.
     * @private
     */
    private removeZone;
    /**
     * Opens the file browser dialog and processes selected files.
     * @returns Promise that resolves when files are processed
     */
    browser(): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXUploaderZoneDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXUploaderZoneDirective, "[axUploaderZone]", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "overlayTemplate": { "alias": "overlayTemplate"; "required": false; "isSignal": true; }; "disableBrowse": { "alias": "disableBrowse"; "required": false; "isSignal": true; }; "disableDragDrop": { "alias": "disableDragDrop"; "required": false; "isSignal": true; }; }, { "fileChange": "fileChange"; "onChanged": "onChanged"; "dragEnter": "dragEnter"; "dragLeave": "dragLeave"; "dragOver": "dragOver"; "onFileUploadComplete": "onFileUploadComplete"; "onFilesUploadComplete": "onFilesUploadComplete"; }, never, never, true, never>;
}

/**
 * Service for managing file uploads with drag-and-drop support, progress tracking, and dialog management.
 * @category Services
 */
declare class AXUploaderService {
    /**
     * Translation service for localized text.
     * @ignore
     */
    private translateService;
    /**
     * File service for file operations.
     * @ignore
     */
    private fileService;
    /**
     * Behavior subject for managing upload requests.
     * @ignore
     */
    private readonly _files$;
    /**
     * Gets the files behavior subject for observing upload requests.
     */
    readonly files: rxjs.Observable<AXUploadRequest[]>;
    /**
     * Subject for file upload start events.
     */
    readonly onFileUploadStart: Subject<AXUploaderFileStartEvent>;
    /**
     * Subject for file upload complete events.
     */
    readonly onFileUploadComplete: Subject<AXUploaderFileCompleteEvent>;
    /**
     * Subject for all files upload complete events.
     */
    readonly onFilesUploadComplete: Subject<AXUploaderFilesCompleteEvent>;
    /**
     * Subject for file upload canceled events.
     */
    readonly onFileUploadCanceled: Subject<AXUploaderFileCancelEvent>;
    /**
     * Signal indicating if any upload has determined progress.
     */
    readonly isAnyDetermined: _angular_core.Signal<boolean>;
    /**
     * Observable for total estimated upload time.
     */
    readonly totalEstimateTime: rxjs.Observable<number>;
    /**
     * Converts a File object to an AXUploadRequest.
     * @private
     */
    private convertFileToRequest;
    /**
     * Starts uploading files that are in 'new' status.
     * @private
     */
    private startUpload;
    /**
     * Binds event handlers to an upload request.
     * @private
     */
    private bindEvents;
    /**
     * Opens the file browser dialog and returns selected files as upload requests.
     * @param options - Configuration options for file selection
     * @returns Promise that resolves to an array of upload requests
     */
    browse(options?: {
        multiple?: boolean;
        accept?: string;
    }): Promise<AXUploadRequest[]>;
    /**
     * Adds files to the upload queue and starts the upload process.
     * @param files - Files to add to the upload queue
     * @returns Promise that resolves to an array of upload requests
     */
    add(files: FileList | File[]): Promise<AXUploadRequest[]>;
    /**
     * Cancels all pending and in-progress uploads.
     */
    cancelAll(): Promise<void>;
    /**
     * Clears all completed uploads from the queue.
     */
    clearAll(): void;
    /**
     * Removes a specific upload request from the queue.
     * @param item - The upload request to remove
     */
    remove(item: AXUploadRequest): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXUploaderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXUploaderService>;
}

export { AXUploadRequest, AXUploaderBrowseDirective, AXUploaderService, AXUploaderZoneDirective };
export type { AXUploadStatus, AXUploaderChangedEvent, AXUploaderFileCancelEvent, AXUploaderFileCompleteEvent, AXUploaderFileStartEvent, AXUploaderFilesCompleteEvent };