ngx-scandoc 0.0.1 → 1.0.1

package/core/app.worker.d.ts

@@ -0,0 +1 @@
+export declare const workertext = "\n\n\nlet readStream = true;\nasync function blobToBase64(blob) {\n  return new Promise((resolve, _) => {\n    const reader = new FileReader();\n    reader.onloadend = () => resolve(reader.result);\n    reader.readAsDataURL(blob);\n  });\n}\nasync function delay(ms) {\n  return new Promise((resolve) =>\n    ms > 0 ? setTimeout(resolve, ms) : resolve(0)\n  );\n}\n\nfunction calculateDelay(startTime) {\n  const endTime = Date.now();\n  // difference in ms\n  const dt = endTime - startTime;\n  const delay = 100 - dt;\n // console.log('[WORKER TIME]', dt, '[DELAY 100-x]', delay);\n  return delay > 4 ? delay : 0;\n}\nasync function parseFrame(frameStream, trackSettings) {\n  const reader = frameStream.getReader();\n\n  while (readStream) {\n    const time = Date.now();\n    const result = await reader.read();\n    if (result.done) break;\n\n    const frameFromCamera = result.value;\n\n    await parseFrameFromCamera(frameFromCamera, trackSettings);\n    // wait\n    await delay(calculateDelay(time));\n  }\n}\n\nasync function parseFrameFast(frameStream, trackSettings) {\n  console.warn('FAST', performance.now());\n  const reader = frameStream.getReader();\n  const { width, height } = trackSettings;\n  const offscreenSmall = new OffscreenCanvas(384, 384);\n  const context = offscreenSmall.getContext('2d');\n  let time = 0;\n  while (true) {\n    // const t0 = performance.now();\n    //  console.time('result');\n    const result = reader.read();\n    //  console.timeEnd('result');\n    if (result.done) break;\n\n    const frameFromCamera = result.value;\n    // console.log(frameFromCamera.timestamp);\n\n    // const tt = frameFromCamera.timestamp - time;\n    // console.log(tt / 1000);\n    // time = frameFromCamera.timestamp;\n\n    // console.time('bitmap');\n    const bitmap = await createImageBitmap(frameFromCamera, {\n      premultiplyAlpha: 'default',\n    });\n    console.warn(new Date().getTime());\n    // console.timeEnd('bitmap');\n\n    // context.clearRect(0, 0, 384, 384);\n    // console.time('draw');\n    // context.drawImage(bitmap, 0, 0, width, height, 0, 0, 384, 384);\n    // console.timeEnd('draw');\n    // console.time('transfer');\n    // const bitmapSmall = offscreenSmall.transferToImageBitmap();\n    // console.timeEnd('transfer');\n\n    frameFromCamera.close();\n    // //\n    // const t1 = performance.now();\n\n\n    // await parseFrameFromCamera(frameFromCamera, trackSettings);\n  }\n}\n\nasync function parseFrameFromCamera(frameFromCamera, trackSettings) {\n  const { width, height } = trackSettings;\n  const offscreenSmall = new OffscreenCanvas(384, 384);\n  // console.time('bit2');\n  const bitmap = await createImageBitmap(frameFromCamera, {\n    premultiplyAlpha: 'default',\n  });\n  // console.timeEnd('bit2');\n  const context = offscreenSmall.getContext('2d');\n\n  //      console.time('buffer');\n  //      const buffer = new Uint8Array(frameFromCamera.allocationSize());\n  //      let layout = await frameFromCamera.copyTo(buffer);\n\n  //       const base64 = await blobToBase64(new Blob([buffer]));\n  // console.log(base64)\n  //      console.timeEnd('buffer');\n\n  if (context) {\n    context.imageSmoothingEnabled = false;\n\n    // let videoFrame2 = frameFromCamera.clone();\n\n    //   createImageBitmap();\n\n    // console.time('clear');\n    // context.clearRect(0, 0, width, height);\n    //  console.timeEnd('clear');\n    // console.time('draw');\n    context.drawImage(bitmap, 0, 0, width, height, 0, 0, 384, 384);\n    // console.timeEnd('draw');\n    // context.drawImage(bit, 0, 0);\n    //  bit2.close();\n    //  bit.close();\n    //  console.timeEnd('draw');\n    // console.time('capture');\n\n    // const bitmapsmall = offscreenSmall.transferToImageBitmap();\n\n    // const imageData = context.getImageData(0, 0, 384, 384);\n    //  console.timeEnd('capture');\n    // console.time('blob');\n    const resized = await offscreenSmall.convertToBlob({\n      type: 'image/jpeg',\n    });\n    // console.timeEnd('blob');\n    //  console.log(resized);\n    //  console.time('base64');\n    const base64 = await blobToBase64(resized);\n    //console.timeEnd('base64');\n    // console.log(blob);\n\n    // console.time('convert')\n    // await convert(bitmap, trackSettings)\n    // console.timeEnd('convert');\n    // console.log(\n    //   '%c ',\n    //   'font-size:384px; background:url('+blob+') no-repeat;'\n    // );\n\n    //   console.timeEnd('blob');\n    postMessage({ base64, bitmap }, [bitmap]);\n    // videoFrame2.close();\n  }\n  frameFromCamera.close();\n}\n\nasync function convert(image, trackSettings) {\n  const { width, height } = trackSettings;\n\n  const offscreenSmall = new OffscreenCanvas(width, height);\n\n  const context = offscreenSmall.getContext('2d');\n\n  // console.time('buffer');\n  // const buffer = new Uint8Array(frameFromCamera.allocationSize());\n  // let layout = await frameFromCamera.copyTo(buffer);\n  // console.timeEnd('buffer');\n\n  if (context) {\n    context.imageSmoothingEnabled = false;\n    // let videoFrame2 = frameFromCamera.clone();\n    console.warn(image);\n    //   createImageBitmap();\n\n    // console.time('clear');\n    // context.clearRect(0, 0, width, height);\n    // console.timeEnd('clear');\n\n    context.drawImage(image, 0, 0);\n    // context.drawImage(bit, 0, 0);\n    // image.close();\n    // console.timeEnd('drawB');\n    console.time('blob2');\n    const resized = await offscreenSmall.convertToBlob({\n      type: 'image/jpeg',\n    });\n    console.timeEnd('blob2');\n\n    // image.close();\n    // console.time('base64');\n    const base64 = await blobToBase64(resized);\n\n    // console.log(blob);\n\n    // console.log(\n    //   '%c ',\n    //   'font-size:384px; background:url(' + base64 + ') no-repeat;'\n    // );\n\n    //  console.timeEnd('base64');\n    //postMessage({ type: 'convert', base64 });\n  }\n}\naddEventListener('message', ({ data }) => {\n  const { type, image, frameStream, trackSettings } = data;\n  // console.log(data);\n  switch (type) {\n    case 'start':\n      readStream = true;\n      parseFrame(frameStream, trackSettings);\n      break;\n\n    case 'fast':\n      readStream = true;\n      parseFrameFast(frameStream, trackSettings);\n      break;\n\n    case 'stop':\n      console.warn('STOP WORKER');\n      readStream = false;\n      break;\n\n    case 'convert':\n      convert(image, trackSettings);\n      break;\n  }\n\n  // const canvas = document.createElement('canvas');\n  // const ctx = canvas.getContext('2d');\n\n  // if (data.canvas) {\n  //   postMessage('ok');\n  // } else {\n\n  //   postMessage(response);\n  // }\n});\n";

package/core/components/components.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./webcam/webcam.module";
+export declare class CoreComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreComponentsModule, never, [typeof i1.CommonModule, typeof i2.WebcamModule], [typeof i2.WebcamModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreComponentsModule>;
+}

package/core/components/webcam/domain/webcam-image.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Container class for a captured webcam image
+ * @author basst314, davidshen84
+ */
+export declare class WebcamImage {
+    constructor(imageAsDataUrl: string, mimeType: string, imageData: ImageData, resized: any);
+    private readonly _mimeType;
+    private _imageAsBase64?;
+    private readonly _imageAsDataUrl;
+    private readonly _imageData;
+    private readonly _imageResized;
+    /**
+     * Extracts the Base64 data out of the given dataUrl.
+     * @param dataUrl the given dataUrl
+     * @param mimeType the mimeType of the data
+     */
+    private static getDataFromDataUrl;
+    /**
+     * Get the base64 encoded image data
+     * @returns base64 data of the image
+     */
+    get imageAsBase64(): string;
+    /**
+     * Get the encoded image as dataUrl
+     * @returns the dataUrl of the image
+     */
+    get imageAsDataUrl(): string;
+    /**
+     * Get the ImageData object associated with the canvas' 2d context.
+     * @returns the ImageData of the canvas's 2d context.
+     */
+    get imageData(): ImageData;
+    get imageResized(): string;
+    get dataUrl(): string;
+}

package/core/components/webcam/domain/webcam-init-error.d.ts

@@ -0,0 +1,4 @@
+export declare class WebcamInitError {
+    message?: string;
+    mediaStreamError?: any;
+}

package/core/components/webcam/domain/webcam-mirror-properties.d.ts

@@ -0,0 +1,3 @@
+export declare class WebcamMirrorProperties {
+    x?: string;
+}

package/core/components/webcam/util/webcam.util.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+export declare class WebcamUtil {
+    /**
+     * Lists available videoInput devices
+     * @returns a list of media device info.
+     */
+    static getAvailableVideoInputs(): Observable<MediaDeviceInfo[]>;
+}

package/core/components/webcam/webcam/webcam.component.d.ts

@@ -0,0 +1,202 @@
+import { AfterViewInit, ChangeDetectorRef, EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import { WebcamInitError } from '../domain/webcam-init-error';
+import { WebcamImage } from '../domain/webcam-image';
+import { Observable, Subject } from 'rxjs';
+import { WebcamMirrorProperties } from '../domain/webcam-mirror-properties';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { Platform } from '@angular/cdk/platform';
+import * as i0 from "@angular/core";
+export declare class WebcamComponent implements AfterViewInit, OnDestroy {
+    breakpointObserver: BreakpointObserver;
+    platform: Platform;
+    private cd;
+    private zone;
+    trackProcessor: any;
+    trackSettings: any;
+    imageHandler: Subject<any>;
+    private static DEFAULT_VIDEO_OPTIONS;
+    private static DEFAULT_IMAGE_TYPE;
+    private static DEFAULT_IMAGE_QUALITY;
+    id?: any;
+    type?: 'document' | 'selfie';
+    /** Defines the max width of the webcam area in px */
+    width: number;
+    /** Defines the max height of the webcam area in px */
+    height: number;
+    /** Defines base constraints to apply when requesting video track from UserMedia */
+    videoOptions: MediaTrackConstraints;
+    /** Flag to enable/disable camera switch. If enabled, a switch icon will be displayed if multiple cameras were found */
+    allowCameraSwitch: boolean;
+    /** Parameter to control image mirroring (i.e. for user-facing camera). ["auto", "always", "never"] */
+    mirrorImage?: string | WebcamMirrorProperties;
+    /** Flag to control whether an ImageData object is stored into the WebcamImage object. */
+    captureImageData: boolean;
+    /** The image type to use when capturing snapshots */
+    imageType: string;
+    /** The image quality to use when capturing snapshots (number between 0 and 1) */
+    imageQuality: number;
+    /** EventEmitter which fires when an image has been captured */
+    imageCapture: EventEmitter<WebcamImage>;
+    /** Emits a mediaError if webcam cannot be initialized (e.g. missing user permissions) */
+    initError: EventEmitter<WebcamInitError>;
+    /** Emits when the webcam video was clicked */
+    imageClick: EventEmitter<void>;
+    /** Emits the active deviceId after the active video device was switched */
+    cameraSwitched: EventEmitter<string>;
+    videoReady: EventEmitter<boolean>;
+    showVideo: boolean;
+    destroyed: EventEmitter<any>;
+    /** available video devices */
+    availableVideoInputs: MediaDeviceInfo[];
+    /** Indicates whether the video device is ready to be switched */
+    videoInitialized: boolean;
+    canvasEl: HTMLCanvasElement;
+    /** If the Observable represented by this subscription emits, an image will be captured and emitted through
+     * the 'imageCapture' EventEmitter */
+    private triggerSubscription?;
+    /** Index of active video in availableVideoInputs */
+    private activeVideoInputIndex;
+    /** Subscription to switchCamera events */
+    private switchCameraSubscription?;
+    /** MediaStream object in use for streaming UserMedia data */
+    private mediaStream;
+    private video;
+    private videoStreamer;
+    /** Canvas for Video Snapshots */
+    private canvas;
+    /** Canvas for Video Snapshots */
+    private canvasSnapshot;
+    private canvasResize;
+    /** width and height of the active video stream */
+    activeVideoSettings: any;
+    shutdown: boolean;
+    private canStart;
+    videoSize: any;
+    canvasSize: any;
+    worker?: Worker;
+    /**
+     * If the given Observable emits, an image will be captured and emitted through 'imageCapture' EventEmitter
+     */
+    set trigger(trigger: Observable<number>);
+    /**
+     * If the given Observable emits, the active webcam will be switched to the one indicated by the emitted value.
+     * @param switchCamera Indicates which webcam to switch to
+     *   true: cycle forwards through available webcams
+     *   false: cycle backwards through available webcams
+     *   string: activate the webcam with the given id
+     */
+    switchCamera: any;
+    onResize(): void;
+    constructor(breakpointObserver: BreakpointObserver, platform: Platform, cd: ChangeDetectorRef, zone: NgZone);
+    /**
+     * Get MediaTrackConstraints to request streaming the given device
+     * @param deviceId
+     * @param baseMediaTrackConstraints base constraints to merge deviceId-constraint into
+     * @returns
+     */
+    private static getMediaConstraintsForDevice;
+    /**
+     * Tries to harvest the deviceId from the given mediaStreamTrack object.
+     * Browsers populate this object differently; this method tries some different approaches
+     * to read the id.
+     * @param mediaStreamTrack
+     * @returns deviceId if found in the mediaStreamTrack
+     */
+    private static getDeviceIdFromMediaStreamTrack;
+    /**
+     * Tries to harvest the facingMode from the given mediaStreamTrack object.
+     * Browsers populate this object differently; this method tries some different approaches
+     * to read the value.
+     * @param mediaStreamTrack
+     * @returns facingMode if found in the mediaStreamTrack
+     */
+    private static getFacingModeFromMediaStreamTrack;
+    /**
+     * Determines whether the given mediaStreamTrack claims itself as user facing
+     * @param mediaStreamTrack
+     */
+    private static isUserFacing;
+    landscape: boolean;
+    /**
+     * Extracts the value from the given ConstrainDOMString
+     * @param constrainDOMString
+     */
+    private static getValueFromConstrainDOMString;
+    resizeStage(): void;
+    get canvasHeight(): number;
+    updatecanvasSize(): void;
+    private setupWorker;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private takeSelfie;
+    /**
+     * Takes a snapshot of the current webcam's view and emits the image as an event
+     */
+    takeSnapshot(time: number): void;
+    private update;
+    resizeImage(base64data: any): Observable<any>;
+    /**
+     * Switches to the next/previous video device
+     * @param forward
+     */
+    rotateVideoInput(forward: boolean): void;
+    /**
+     * Switches the camera-view to the specified video device
+     */
+    switchToVideoInput(deviceId: string): void;
+    /**
+     * Event-handler for video resize event.
+     * Triggers Angular change detection so that new video dimensions get applied
+     */
+    videoResize(): void;
+    get videoWidth(): number;
+    get videoHeight(): number;
+    get videoStyleClasses(): string;
+    get nativeVideoElement(): any;
+    /**
+     * Returns the video aspect ratio of the active video stream
+     */
+    private getVideoAspectRatio;
+    private updateSize;
+    getStreamTrack(stream: MediaStream): MediaStreamTrack;
+    getTrackSettings(): void;
+    accesVideoTrack(videoTrackConstraints: MediaStreamConstraints): any;
+    private drawRectangle;
+    getMaxAvailableResolution(): void;
+    /**
+     * Init webcam live view
+     */
+    private initWebcam;
+    get isMobile(): boolean;
+    get cardRectangle(): {
+        padding: number;
+        top: number;
+        rWidth: number;
+        rHeight: number;
+    };
+    get snapRectangle(): {
+        padding: number;
+        top: number;
+        rWidth: number;
+        rHeight: number;
+    };
+    private setActiveCamera;
+    private getActiveVideoTrack;
+    private isMirrorImage;
+    /**
+     * Stops all active media tracks.
+     * This prevents the webcam from being indicated as active,
+     * even if it is no longer used by this component.
+     */
+    private stopMediaTracks;
+    /**
+     * Unsubscribe from all open subscriptions
+     */
+    private unsubscribeFromSubscriptions;
+    /**
+     * Reads available input devices
+     */
+    private detectAvailableDevices;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebcamComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WebcamComponent, "app-webcam", never, { "imageHandler": "imageHandler"; "id": "id"; "type": "type"; "width": "width"; "height": "height"; "videoOptions": "videoOptions"; "allowCameraSwitch": "allowCameraSwitch"; "mirrorImage": "mirrorImage"; "captureImageData": "captureImageData"; "imageType": "imageType"; "imageQuality": "imageQuality"; "trigger": "trigger"; "switchCamera": "switchCamera"; }, { "imageCapture": "imageCapture"; "initError": "initError"; "imageClick": "imageClick"; "cameraSwitched": "cameraSwitched"; "videoReady": "videoReady"; "destroyed": "destroyed"; }, never, never, false>;
+}

package/core/components/webcam/webcam.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./webcam/webcam.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/cdk/platform";
+export declare class WebcamModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebcamModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<WebcamModule, [typeof i1.WebcamComponent], [typeof i2.CommonModule, typeof i3.PlatformModule], [typeof i1.WebcamComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<WebcamModule>;
+}

package/core/pipes/pipes.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./safeResourceUrl.pipe";
+export declare class CorePipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CorePipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CorePipesModule, [typeof i1.SafeResourceUrlPipe], never, [typeof i1.SafeResourceUrlPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CorePipesModule>;
+}

package/core/pipes/safeResourceUrl.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class SafeResourceUrlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(style: any): import("@angular/platform-browser").SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeResourceUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeResourceUrlPipe, "safeResourceUrl", false>;
+}

package/core/shared/material.module.d.ts

@@ -0,0 +1,28 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/core";
+import * as i2 from "@angular/material/datepicker";
+import * as i3 from "@angular/material/card";
+import * as i4 from "@angular/material/menu";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/dialog";
+import * as i8 from "@angular/material/input";
+import * as i9 from "@angular/material/snack-bar";
+import * as i10 from "@angular/material/progress-bar";
+import * as i11 from "@angular/material/table";
+import * as i12 from "@angular/material/progress-spinner";
+import * as i13 from "@angular/material/paginator";
+import * as i14 from "@angular/material/select";
+import * as i15 from "@angular/material/checkbox";
+import * as i16 from "@angular/material/chips";
+import * as i17 from "@angular/material/badge";
+import * as i18 from "@angular/material/list";
+import * as i19 from "@angular/material/tabs";
+import * as i20 from "@angular/material/slider";
+import * as i21 from "@angular/material/slide-toggle";
+import * as i22 from "@angular/material/autocomplete";
+export declare class MaterialModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaterialModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MaterialModule, never, [typeof i1.MatNativeDateModule, typeof i2.MatDatepickerModule, typeof i3.MatCardModule, typeof i4.MatMenuModule, typeof i5.MatIconModule, typeof i6.MatButtonModule, typeof i7.MatDialogModule, typeof i8.MatInputModule, typeof i9.MatSnackBarModule, typeof i10.MatProgressBarModule, typeof i11.MatTableModule, typeof i12.MatProgressSpinnerModule, typeof i13.MatPaginatorModule, typeof i14.MatSelectModule, typeof i15.MatCheckboxModule, typeof i16.MatChipsModule, typeof i17.MatBadgeModule, typeof i18.MatListModule, typeof i19.MatTabsModule, typeof i20.MatSliderModule, typeof i21.MatSlideToggleModule], [typeof i1.MatNativeDateModule, typeof i2.MatDatepickerModule, typeof i14.MatSelectModule, typeof i3.MatCardModule, typeof i4.MatMenuModule, typeof i5.MatIconModule, typeof i6.MatButtonModule, typeof i7.MatDialogModule, typeof i8.MatInputModule, typeof i9.MatSnackBarModule, typeof i10.MatProgressBarModule, typeof i12.MatProgressSpinnerModule, typeof i11.MatTableModule, typeof i13.MatPaginatorModule, typeof i16.MatChipsModule, typeof i17.MatBadgeModule, typeof i15.MatCheckboxModule, typeof i18.MatListModule, typeof i19.MatTabsModule, typeof i21.MatSlideToggleModule, typeof i22.MatAutocompleteModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MaterialModule>;
+}

package/dialogs/components/blank/blank.component.d.ts

@@ -0,0 +1,17 @@
+import { ComponentFactoryResolver, ViewContainerRef, AfterViewInit, ChangeDetectorRef } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class BlankComponent implements AfterViewInit {
+    dialogRef: MatDialogRef<BlankComponent>;
+    data: any;
+    private componentFactoryResolver;
+    cd: ChangeDetectorRef;
+    body?: ViewContainerRef;
+    initSet: boolean;
+    constructor(dialogRef: MatDialogRef<BlankComponent>, data: any, componentFactoryResolver: ComponentFactoryResolver, cd: ChangeDetectorRef);
+    setModel(model: any): void;
+    init(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlankComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlankComponent, "app-dialog-blank", never, {}, {}, never, never, false>;
+}

package/dialogs/components/confirm/confirm.component.d.ts

@@ -0,0 +1,30 @@
+import { OnInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+interface options {
+    hideOkButton?: boolean;
+    hideCancelButton?: boolean;
+    hideNoButton?: boolean;
+    type?: string;
+}
+export declare class ConfirmComponent implements OnInit {
+    dialogRef: MatDialogRef<ConfirmComponent>;
+    data: any;
+    showDetails: boolean;
+    images: {
+        alert: string;
+        prompt: string;
+        dirty: string;
+    };
+    type: any;
+    options: options;
+    onEnterPress(e: KeyboardEvent): void;
+    onEscapePress(e: KeyboardEvent): void;
+    constructor(dialogRef: MatDialogRef<ConfirmComponent>, data: any);
+    ngOnInit(): void;
+    action(key: any): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmComponent, "app-confirm", never, {}, {}, never, never, false>;
+}
+export {};

package/dialogs/components/loading/loading.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class LoadingComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingComponent, "app-loading", never, {}, {}, never, never, false>;
+}

package/dialogs/components/scan-mobile/scan-mobile.component.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { webRtcProvider } from '../../../providers/webrtc.provider';
+import * as i0 from "@angular/core";
+export declare class ScanMobileComponent implements OnInit {
+    dialogRef: MatDialogRef<ScanMobileComponent>;
+    data: any;
+    private rtcProvider;
+    code: any;
+    constructor(dialogRef: MatDialogRef<ScanMobileComponent>, data: any, rtcProvider: webRtcProvider);
+    ngOnInit(): void;
+    close(): void;
+    action(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScanMobileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScanMobileComponent, "app-scan-mobile", never, {}, {}, never, never, false>;
+}

package/dialogs/components/scan-profile/scan-profile.component.d.ts

@@ -0,0 +1,124 @@
+import { EventEmitter, ElementRef, ChangeDetectorRef, AfterViewInit, OnDestroy, NgZone } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { Subject, Observable, Subscription } from 'rxjs';
+import { FormGroup } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import { ScanProvider } from '../../../providers/scan.provider';
+import { DialogsCoreProvider } from '../../../dialogs/dialogs.core.provider';
+import { WebcamImage } from '../../../core/components/webcam/domain/webcam-image';
+import { WebcamInitError } from '../../../core/components/webcam/domain/webcam-init-error';
+import { ScanFieldsProvider } from '../../../providers/scan.form';
+import { AuthProvider } from '../../../providers/auth.provider';
+import * as i0 from "@angular/core";
+export interface IWindow extends Window {
+    TextDetector: any;
+}
+interface Troubleshooting {
+    Request: any;
+    Response: any;
+    ExpectedOutput: any;
+    AcceptTermsAndConditions: boolean;
+}
+interface Timestamps {
+    time: number;
+    load: number;
+}
+export declare class ScanProfileComponent implements AfterViewInit, OnDestroy {
+    cd: ChangeDetectorRef;
+    scanProvider: ScanProvider;
+    private dialogs;
+    private formProvider;
+    private zone;
+    private translate;
+    private auth;
+    scanBlastData: any;
+    type: string;
+    actions: EventEmitter<any>;
+    mediaDevices: any;
+    deviceId?: string;
+    videoOptions: MediaTrackConstraints;
+    dialogRef?: MatDialogRef<any>;
+    data: any;
+    startTime: number;
+    isDebug: boolean;
+    multipleWebcamsAvailable: boolean;
+    scanInProgress: boolean;
+    fields: any;
+    documentTypeSelected: boolean;
+    imageHandlerSubscription: Subscription;
+    selectedSide: any;
+    images: any;
+    scanTimeout: any;
+    preview: any;
+    scanType: any;
+    width: any;
+    height: any;
+    videoWidth: any;
+    videoHeight: any;
+    errorCode: string;
+    displayInfo: any;
+    allowCameraSwitch: boolean;
+    verificationErrorSent: boolean;
+    error: boolean;
+    cameraReady: boolean;
+    result: any;
+    scaning: boolean;
+    imageHandler: Subject<unknown>;
+    logData: Troubleshooting;
+    defaultDevice: any;
+    scanDatas: any;
+    scanSide: any;
+    idScan: any;
+    webcamImage?: WebcamImage;
+    model: any;
+    validation: boolean;
+    scannedImages: any[];
+    scanDelay: any;
+    trigger: Subject<number>;
+    nextWebcam: Subject<boolean | string>;
+    imageVerified: boolean;
+    form: FormGroup<{}>;
+    scanImageTimestamps: Timestamps;
+    wraper?: ElementRef;
+    onResize(): void;
+    constructor(cd: ChangeDetectorRef, scanProvider: ScanProvider, dialogs: DialogsCoreProvider, formProvider: ScanFieldsProvider, zone: NgZone, translate: TranslateService, auth: AuthProvider);
+    private resetLogData;
+    ngOnDestroy(): void;
+    init(): void;
+    scan(): void;
+    private DataUrlFromImage;
+    handleImage(webcamImage: WebcamImage): void;
+    private handleBurstData;
+    handleInitError(error: WebcamInitError): void;
+    get scanBlastCanUpload(): boolean;
+    cameraWasSwitched(deviceId: string): void;
+    get nextWebcamObservable(): Observable<boolean | string>;
+    private handleLongValidationError;
+    ngAfterViewInit(): void;
+    handleBitmapImage(bitmap: any): any;
+    autoScan(): void;
+    selectCamera(event: any): void;
+    close(): void;
+    singleScan(side: any): void;
+    getBase64(file: any): Observable<unknown>;
+    handleFileInput(target: any, event: any, side: any): void;
+    rotateBase64Image(base64data: any): Observable<unknown>;
+    sendMobile(): void;
+    singleScanRotate(side: any): void;
+    singleScanRemove(side: any): void;
+    resolutionLimit(file: any): Observable<unknown>;
+    private getImgBase64;
+    scanBlastFinish(): void;
+    cameraOff(ev: any): void;
+    continue(): void;
+    retry(): void;
+    triggerSnapshot(): void;
+    retake(): void;
+    cancel(): void;
+    use(): void;
+    selfie(): void;
+    videoReady(event: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScanProfileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScanProfileComponent, "app-scan-profile", never, { "type": "type"; }, { "actions": "actions"; }, never, never, false>;
+}
+export {};

package/dialogs/components/scan-selfie/scan-selfie.component.d.ts

@@ -0,0 +1,83 @@
+import { EventEmitter, ElementRef, ChangeDetectorRef, AfterViewInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { Subject, Observable } from 'rxjs';
+import { FormGroup } from '@angular/forms';
+import { WebcamImage } from '../../../core/components/webcam/domain/webcam-image';
+import { WebcamInitError } from '../../../core/components/webcam/domain/webcam-init-error';
+import { DialogsCoreProvider } from '../../../dialogs/dialogs.core.provider';
+import { TranslateService } from '@ngx-translate/core';
+import { ScanProvider } from '../../../providers/scan.provider';
+import * as i0 from "@angular/core";
+export interface IWindow extends Window {
+    TextDetector: any;
+}
+export declare class ScanSelfieComponent implements AfterViewInit {
+    cd: ChangeDetectorRef;
+    scanProvider: ScanProvider;
+    private dialogs;
+    private translate;
+    scanBlastData: any;
+    type: string;
+    actions: EventEmitter<any>;
+    mediaDevices: any;
+    deviceId?: string;
+    videoOptions: MediaTrackConstraints;
+    dialogRef?: MatDialogRef<any>;
+    data: any;
+    multipleWebcamsAvailable: boolean;
+    fields: any;
+    documentTypeSelected: boolean;
+    selectedSide: any;
+    images: any;
+    preview: any;
+    scanType: any;
+    width: any;
+    height: any;
+    videoWidth: any;
+    videoHeight: any;
+    allowCameraSwitch: boolean;
+    error: boolean;
+    cameraReady: boolean;
+    result: any;
+    scaning: boolean;
+    defaultDevice: any;
+    scanDatas: any;
+    scanSide: any;
+    webcamImage?: WebcamImage;
+    model: any;
+    trigger: Subject<number>;
+    nextWebcam: Subject<boolean | string>;
+    form: FormGroup<{}>;
+    wraper?: ElementRef;
+    onResize(): void;
+    constructor(cd: ChangeDetectorRef, scanProvider: ScanProvider, dialogs: DialogsCoreProvider, translate: TranslateService);
+    init(): void;
+    handleImage(webcamImage: WebcamImage): void;
+    handleInitError(error: WebcamInitError): void;
+    get scanBlastCanUpload(): boolean;
+    cameraWasSwitched(deviceId: string): void;
+    get nextWebcamObservable(): Observable<boolean | string>;
+    ngAfterViewInit(): void;
+    selectCamera(event: any): void;
+    close(): void;
+    singleScan(side: any): void;
+    getBase64(file: any): Observable<unknown>;
+    handleFileInput(target: any, event: any, side: any): void;
+    rotateBase64Image(base64data: any): Observable<unknown>;
+    sendMobile(): void;
+    singleScanRotate(side: any): void;
+    singleScanRemove(side: any): void;
+    resolutionLimit(file: any): Observable<unknown>;
+    private getImgBase64;
+    scanBlastFinish(): void;
+    cameraOff(ev: any): void;
+    continue(): void;
+    retry(): void;
+    triggerSnapshot(): void;
+    scan(): void;
+    retake(): void;
+    use(): void;
+    selfie(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScanSelfieComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScanSelfieComponent, "app-scan-selfie", never, { "type": "type"; }, { "actions": "actions"; }, never, never, false>;
+}

package/dialogs/dialogs.core.provider.d.ts

@@ -0,0 +1,18 @@
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { BlankComponent } from './components/blank/blank.component';
+import * as i0 from "@angular/core";
+export declare class DialogsCoreProvider {
+    private matDialog;
+    components: any;
+    private blank;
+    constructor(matDialog: MatDialog);
+    private getComponent;
+    open(config: any, withComponent?: boolean): MatDialogRef<BlankComponent, any>;
+    scanProfile(data: any): MatDialogRef<BlankComponent, any>;
+    loading(title?: string): MatDialogRef<BlankComponent, any>;
+    alert(title: string, text: string): MatDialogRef<BlankComponent, any>;
+    scanMobile(data: any): MatDialogRef<BlankComponent, any>;
+    scanSelfie(data: any): MatDialogRef<BlankComponent, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogsCoreProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogsCoreProvider>;
+}