/************
Processor: ts
************/

import * as __beyond_dep_ns_0 from '@beyond-js/reactive/model';
// draggable.ts
declare namespace ns_0 {
  export class DraggableUploader {
    #private;
    constructor(parent: any);
    onDrop: (event: DragEvent) => void;
    /**
     * This event runs only when are files on the draggable area.
     * @param event
     */
    onDragOver: (event: DragEvent) => void;
    /**
     * Add the drag & drop events to the control
     * @param {HTMLInputElement} selector
     */
    add(selector: HTMLInputElement): void;
  }
}


// files\base.ts
declare namespace ns_1 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  interface IFile {}
  export class BaseFile extends ReactiveModel<IFile> {
    #private;
    private regExp;
    get errors(): any[];
    protected _total: number;
    get total(): number;
    set total(value: number);
    protected _items: Map<any, any>;
    get items(): Map<any, any>;
    get entries(): any[];
    constructor(parent: any, specs: any);
    protected FILE_TYPE: Readonly<{
      document: string[];
      image: string[];
      json: string[];
      zip: string[];
      audio: string[];
    }>;
    validate: (file: any) => boolean;
    clean: () => void;
    /**
     *
     * @param fileList
     */
    readLocal: (fileList: File[]) => Promise<void>;
  }
  export {};
}


// files\index.ts
declare namespace ns_2 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  export class FilesUploader extends ReactiveModel<FilesUploader> {
    #private;
    static getInstance(parent: any, specs: any): any;
  }
}


// files\mobile.ts
declare namespace ns_3 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  export class MobileFilesUploader extends ReactiveModel<MobileFilesUploader> {
    private _loaded;
    private files;
    private base64?;
    private _specs;
    private _errors;
    constructor(specs: any);
    clean: () => void;
    getFiles: (data: any) => Promise<void>;
    get entries(): Map<any, any>;
    get total(): number;
  }
}


// files\web.ts
declare namespace ns_4 {
  import BaseFile = ns_1.BaseFile;
  export class WebFilesUploader extends BaseFile {}
}


// index.ts
declare namespace ns_5 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  import BaseFile = ns_1.BaseFile;
  interface IUploader {
    files: BaseFile;
  }
  export class Uploader extends ReactiveModel<IUploader> {
    #private;
    get files(): BaseFile;
    get errors(): any;
    constructor(specs?: any);
    setAttributes: (specs: any) => void;
    openDialog: () => void;
    filesLoaded: () => void;
    pictureLoaded: () => void;
    pictureLoading: () => void;
    getErrors: () => any[];
    clean: () => Promise<void>;
    delete: (fileName: string) => Promise<void>;
    create: (selector: HTMLElement, draggableSelector: HTMLElement | undefined) => void;
    publish: (additionalParams?: {}) => Promise<any>;
  }
  export {};
}


// resize.ts
declare namespace ns_6 {
  export const resizePicture: (uri: any, specs: any) => Promise<unknown>;
}


// xhr.ts
declare namespace ns_7 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  export class XHRLoader extends ReactiveModel<XHRLoader> {
    #private;
    private promise;
    private uploaded;
    private progress;
    private error;
    constructor();
    bearer(bearer: string | undefined): this;
    get uploading(): boolean;
    get isUploaded(): boolean;
    get uploadProgress(): number;
    get hasError(): boolean;
    private onProgress;
    private onCompleted;
    private onError;
    private onAbort;
    getHeaders: (specs: any) => Headers;
    upload(data: FormData, url: string): Promise<Response>;
    abort(): void;
  }
}


export import Uploader = ns_5.Uploader;
export import XHRLoader = ns_7.XHRLoader;

export declare const hmr: {on: (event: string, listener: any) => void, off: (event: string, listener: any) => void };