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

import * as __beyond_dep_ns_0 from '@beyond-js/reactive/model';
// desktop.ts
declare namespace ns_0 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  import ICamera = ns_3.ICamera;
  import InputFile = ns_5.InputFile;
  import IPublishParams = ns_6.IPublishParams;
  class MediaDevice extends ReactiveModel<ICamera> implements ICamera {
    #private;
    private static instance;
    readonly PLATFORM: string;
    get isReady(): boolean;
    constructor();
    private getUserMedia;
    activateCamera(constraints: MediaStreamConstraints, selector: HTMLVideoElement): Promise<void>;
    static getInstance(): MediaDevice;
    desactivateCamera(): void;
    /**
     *
     * @param options
     * @returns
     */
    getPicture(): Promise<Blob>;
    private clean;
    getVideoStream(): Promise<MediaStream>;
    takePicture(options: object): void;
    openGallery(selector: any, specs?: {}): void;
    upload(url: any, specs?: {}): void;
    setInputFile(input: any): InputFile;
    publish: (url: any, params: IPublishParams) => Promise<any>;
  }
  export const DesktopMediaDevice: MediaDevice;
  export {};
}


// file-manager.ts
declare namespace ns_1 {
  /**
   * REturns a valid url of the image loaded
   *
   * @platform mobile
   * @param data
   * @returns
   */
  export function getUrl(data: any): any;
}


// files\index.ts
declare namespace ns_2 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  export class MediaFiles extends ReactiveModel<MediaFiles> {
    #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;
    /**
     * Read Local files uploaded from an input file
     *
     * @param fileList
     */
    readLocal: (fileList: File[]) => Promise<void>;
    getMobileUrl(data: any): any;
  }
}


// i-camera.ts
declare namespace ns_3 {
  export interface ICamera {
    isReady: boolean;
    readonly PLATFORM: string;
    getPicture: Function;
    openGallery: Function;
  }
}


// index.ts
declare namespace ns_4 {
  export const /*bundle*/mediaDevice: any;
}


// input.ts
declare namespace ns_5 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  import MediaFiles = ns_2.MediaFiles;
  export class InputFile extends ReactiveModel<InputFile> {
    #private;
    get files(): MediaFiles;
    constructor(selector: HTMLInputElement, files: MediaFiles, specs?: {});
    filesLoaded: () => void;
    pictureLoaded: () => void;
    pictureLoading: () => void;
    getErrors: () => void;
    openDialog: () => void;
    setAttributes: (specs: any) => void;
    clean: () => Promise<void>;
    create(): void;
  }
}


// interfaces.ts
declare namespace ns_6 {
  export interface IPublishParams {
    name: string;
  }
  export interface IResponse {
    status: boolean;
    data?: {
      id: number;
      urls: string[];
    };
  }
}


// mobile.ts
declare namespace ns_7 {
  import ReactiveModel = __beyond_dep_ns_0.ReactiveModel;
  import ICamera = ns_3.ICamera;
  import IPublishParams = ns_6.IPublishParams;
  global {
    interface Navigator {
      camera?: {
        getPicture: (onSuccess: (response: string) => void, onError: (error: string) => void, options?: any) => void;
      };
    }
  }
  export class MediaCameraDevice extends ReactiveModel<ICamera> implements ICamera {
    #private;
    readonly PLATFORM: string;
    private static instance;
    constructor();
    get isReady(): boolean;
    get source(): any;
    get sourceType(): number;
    set sourceType(value: number);
    get mediaType(): number;
    set mediaType(value: number);
    set source(value: any);
    onSuccess: (data: string) => Promise<void>;
    onFail: (message: string) => void;
    /**
     *
     * @param srcType number 1 = camera, 0 = photolibrary
     * @returns
     */
    setOptions: (overwrites: any) => any;
    getPicture: (options: any) => any;
    openGallery(selector: Element): any;
    static getInstance(): MediaCameraDevice;
    publish: (url: any, params: IPublishParams) => Promise<any>;
  }
  export const MobileMediaDevice: MediaCameraDevice;
}


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


export import mediaDevice = ns_4.mediaDevice;

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