ngx-scandoc 1.2.4 → 1.3.0

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

@@ -1,15 +1,18 @@
+import { ModuleWithProviders } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "./scan/scan.component";
 import * as i2 from "./scan-results/scan-results.component";
 import * as i3 from "./camera-switch/camera-switch.component";
-import * as i4 from "@angular/common";
-import * as i5 from "@angular/forms";
-import * as i6 from "@ngx-translate/core";
-import * as i7 from "./webcam/webcam.module";
-import * as i8 from "../shared/material.module";
-import * as i9 from "../../forms/form.module";
+import * as i4 from "./manual-scan/manual-scan.component";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/forms";
+import * as i7 from "@ngx-translate/core";
+import * as i8 from "./webcam/webcam.module";
+import * as i9 from "../shared/material.module";
+import * as i10 from "../../forms/form.module";
 export declare class CoreComponentsModule {
+    static forRoot(): ModuleWithProviders<CoreComponentsModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CoreComponentsModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreComponentsModule, [typeof i1.ScanComponent, typeof i2.ScanResultsComponent, typeof i3.CameraSwitchComponent], [typeof i4.CommonModule, typeof i5.FormsModule, typeof i6.TranslateModule, typeof i7.WebcamModule, typeof i8.MaterialModule, typeof i9.AppFormModule, typeof i5.ReactiveFormsModule], [typeof i7.WebcamModule, typeof i1.ScanComponent, typeof i3.CameraSwitchComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreComponentsModule, [typeof i1.ScanComponent, typeof i2.ScanResultsComponent, typeof i3.CameraSwitchComponent, typeof i4.ManualScanComponent], [typeof i5.CommonModule, typeof i6.FormsModule, typeof i7.TranslateModule, typeof i8.WebcamModule, typeof i9.MaterialModule, typeof i10.AppFormModule, typeof i6.ReactiveFormsModule], [typeof i8.WebcamModule, typeof i1.ScanComponent, typeof i3.CameraSwitchComponent, typeof i4.ManualScanComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CoreComponentsModule>;
 }

package/core/components/manual-scan/manual-scan.component.d.ts

@@ -0,0 +1,61 @@
+import { EventEmitter, OnDestroy, OnInit, ChangeDetectorRef, ElementRef, NgZone } from '@angular/core';
+import { NgxScandocCameraProvider } from '../../../providers/camera.provider';
+import { Observable, Subject } from 'rxjs';
+import { BaseComponent } from '../base.component';
+import { LayoutProvider } from '../../../providers/layout.provider';
+import * as i0 from "@angular/core";
+export declare class ManualScanComponent extends BaseComponent implements OnInit, OnDestroy {
+    cameraProvider: NgxScandocCameraProvider;
+    private cd;
+    private layoutProvider;
+    private zone;
+    action: EventEmitter<any>;
+    videoOptions: MediaTrackConstraints;
+    cameraReady: boolean;
+    scanBlastData: any;
+    error: boolean;
+    scaning: boolean;
+    documentTypeSelected: boolean;
+    selectedSide: any;
+    preview: any;
+    scanType: any;
+    width: any;
+    height: any;
+    videoWidth: any;
+    videoHeight: any;
+    scanDatas: any;
+    scanSide: any;
+    result: any;
+    webcamImage: any;
+    trigger: Subject<number>;
+    nextWebcam: Subject<boolean | string>;
+    isMobile: boolean;
+    wraper?: ElementRef;
+    get class(): boolean;
+    onResize(): void;
+    constructor(cameraProvider: NgxScandocCameraProvider, cd: ChangeDetectorRef, layoutProvider: LayoutProvider, zone: NgZone);
+    ngOnInit(): void;
+    get nextWebcamObservable(): Observable<boolean | string>;
+    cameraWasSwitched(deviceId: string): void;
+    handleInitError(error: any): void;
+    resolutionLimit(file: any): Observable<unknown>;
+    private getImgBase64;
+    getBase64(file: any): Observable<unknown>;
+    handleFileInput(target: any, event: any, side: any): void;
+    cameraOff(ev: any): void;
+    ngOnDestroy(): void;
+    singleScan(side: any): void;
+    scanBlastFinish(): void;
+    get scanBlastCanUpload(): boolean;
+    handleImage(webcamImage: any): void;
+    continue(): void;
+    retry(): void;
+    triggerSnapshot(): void;
+    scan(): void;
+    rotateBase64Image(base64data: any): Observable<unknown>;
+    singleScanRotate(side: any): void;
+    videoReady(event: boolean): void;
+    singleScanRemove(side: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ManualScanComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ManualScanComponent, "ngx-manual-scan", never, {}, { "action": "action"; }, never, never, false>;
+}

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

@@ -1,6 +1,5 @@
-import { EventEmitter, ElementRef, ChangeDetectorRef, AfterViewInit, OnDestroy, NgZone, Injector } from '@angular/core';
-import { MatDialogRef } from '@angular/material/dialog';
-import { Subject, Observable, Subscription } from 'rxjs';
+import { EventEmitter, ChangeDetectorRef, AfterViewInit, OnDestroy, NgZone, Injector, ViewContainerRef } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
 import { FormGroup } from '@angular/forms';
 import { TranslateService } from '@ngx-translate/core';
 import { ScanProvider } from '../../../providers/scan.provider';
@@ -10,6 +9,8 @@ import { AuthProvider } from '../../../providers/auth.provider';
 import { NgxScandocCameraProvider } from '../../../providers/camera.provider';
 import { LayoutProvider } from '../../../providers/layout.provider';
 import { BaseComponent } from '../base.component';
+import { Platform } from '@angular/cdk/platform';
+import { MatSnackBar } from '@angular/material/snack-bar';
 import * as i0 from "@angular/core";
 export interface IWindow extends Window {
     TextDetector: any;
@@ -27,25 +28,23 @@ interface Timestamps {
 export declare class ScanComponent extends BaseComponent implements AfterViewInit, OnDestroy {
     cd: ChangeDetectorRef;
     private zone;
-    private translate;
     cameraProvider: NgxScandocCameraProvider;
     private injector;
     private layoutProvider;
+    private platform;
+    private translate;
+    private snackBar;
+    private view;
     private auth;
     scanBlastData: any;
     type: string;
     dialogs: any;
     actions: EventEmitter<any>;
-    mediaDevices: any;
     deviceId?: string;
-    videoOptions: MediaTrackConstraints;
-    dialogRef?: MatDialogRef<any>;
-    data: any;
+    scanResults: Subject<unknown>;
+    scanSecondSide: boolean;
     startTime: number;
-    isDebug: boolean;
-    multipleWebcamsAvailable: boolean;
     scanInProgress: boolean;
-    fields: any;
     documentTypeSelected: boolean;
     imageHandlerSubscription: Subscription;
     selectedSide: any;
@@ -53,23 +52,19 @@ export declare class ScanComponent extends BaseComponent implements AfterViewIni
     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;
+    promptManual: boolean;
     frontImage: any;
     backImage: any;
     imageHandler: Subject<unknown>;
+    manualDataSet: boolean;
     logData: Troubleshooting;
-    defaultDevice: any;
     scanDatas: any;
     scanSide: any;
     idScan: any;
@@ -82,39 +77,41 @@ export declare class ScanComponent extends BaseComponent implements AfterViewIni
     nextWebcam: Subject<boolean | string>;
     imageVerified: boolean;
     form: FormGroup<{}>;
+    manual: boolean;
     isMobile: boolean;
     showDialog: boolean;
     scanImageTimestamps: Timestamps;
-    wraper?: ElementRef;
     get class(): boolean;
     onResize(): void;
     scanProvider: ScanProvider;
-    constructor(cd: ChangeDetectorRef, zone: NgZone, translate: TranslateService, cameraProvider: NgxScandocCameraProvider, injector: Injector, layoutProvider: LayoutProvider, auth: AuthProvider);
+    constructor(cd: ChangeDetectorRef, zone: NgZone, cameraProvider: NgxScandocCameraProvider, injector: Injector, layoutProvider: LayoutProvider, platform: Platform, translate: TranslateService, snackBar: MatSnackBar, view: ViewContainerRef, auth: AuthProvider);
     private resetLogData;
-    ngOnDestroy(): void;
     init(): void;
-    cameraOff(ev: any): void;
     continue(): void;
     scan(): void;
     handleImage(webcamImage: WebcamImage): void;
     private handleBurstData;
+    closeDialog(): void;
     handleInitError(error: WebcamInitError): void;
     get scanBlastCanUpload(): boolean;
-    cameraWasSwitched(deviceId: string): void;
-    get nextWebcamObservable(): Observable<boolean | string>;
+    private manualMode;
+    private handleExtractionError;
     private handleLongValidationError;
     ngAfterViewInit(): void;
     handleBitmapImage(bitmap: any): any;
     autoScan(): void;
     singleScan(side: any): void;
+    manualScanData(data: any): void;
     private getImgBase64;
     scanBlastFinish(): void;
     retry(): void;
-    triggerSnapshot(): void;
     retake(): void;
     use(): void;
     selfie(): void;
+    cameraOff(ev: any): void;
     videoReady(event: boolean): void;
+    manualSet(key: boolean): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScanComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ScanComponent, "ngx-scan", never, { "type": "type"; "dialogs": "dialogs"; "showDialog": "showDialog"; }, { "actions": "actions"; }, never, never, false>;
 }

package/core/components/scan-results/scan-results.component.d.ts

@@ -1,20 +1,27 @@
-import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { EventEmitter, OnDestroy, OnInit, ChangeDetectorRef, NgZone } from '@angular/core';
 import { NgxScandocCameraProvider } from '../../../providers/camera.provider';
 import { FormGroup } from '@angular/forms';
 import { ScanFieldsProvider } from '../../../providers/scan.form';
+import { Subject } from 'rxjs';
+import { BaseComponent } from '../base.component';
+import { ScanProvider } from '../../../providers/scan.provider';
 import * as i0 from "@angular/core";
-export declare class ScanResultsComponent implements OnInit, OnDestroy {
+export declare class ScanResultsComponent extends BaseComponent implements OnInit, OnDestroy {
     cameraProvider: NgxScandocCameraProvider;
     private formProvider;
+    private provider;
+    private cd;
+    private zone;
+    data: Subject<any>;
     model: any;
     images: any;
     fields: any;
     form: FormGroup;
     action: EventEmitter<any>;
-    constructor(cameraProvider: NgxScandocCameraProvider, formProvider: ScanFieldsProvider);
+    constructor(cameraProvider: NgxScandocCameraProvider, formProvider: ScanFieldsProvider, provider: ScanProvider, cd: ChangeDetectorRef, zone: NgZone);
     ngOnInit(): void;
     ngOnDestroy(): void;
     selfie(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScanResultsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScanResultsComponent, "ngx-scan-results", never, { "model": "model"; "images": "images"; "form": "form"; }, { "action": "action"; }, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScanResultsComponent, "ngx-scan-results", never, { "data": "data"; "images": "images"; "form": "form"; }, { "action": "action"; }, never, never, false>;
 }

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

@@ -4,5 +4,5 @@ export declare class WebcamUtil {
      * Lists available videoInput devices
      * @returns a list of media device info.
      */
-    static getAvailableVideoInputs(): Observable<MediaDeviceInfo[]>;
+    static getAvailableVideoInputs(facingMode?: 'user' | 'environment'): Observable<MediaDeviceInfo[]>;
 }

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

@@ -2,7 +2,6 @@ import { AfterViewInit, ChangeDetectorRef, EventEmitter, NgZone, OnDestroy } fro
 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 { NgxScandocCameraProvider } from '../../../../providers/camera.provider';
@@ -14,192 +13,39 @@ export declare class WebcamComponent extends BaseComponent implements AfterViewI
     private cd;
     private zone;
     private cameraProvider;
-    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;
+    showVideo: boolean;
+    canvasData: any;
+    mediaStream: MediaStream;
+    imageHandler: Subject<any>;
+    type?: 'document' | 'selfie' | 'manual';
+    trigger: Observable<number>;
+    resizeTimeout: any;
     onResize(): void;
+    private chunks;
+    private canvas;
+    private videoRef;
+    cameraSwitched: EventEmitter<string>;
+    videoReady: EventEmitter<boolean>;
+    imageCapture: EventEmitter<WebcamImage>;
+    initError: EventEmitter<WebcamInitError>;
     constructor(breakpointObserver: BreakpointObserver, platform: Platform, cd: ChangeDetectorRef, zone: NgZone, cameraProvider: NgxScandocCameraProvider);
-    /**
-     * 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;
+    get video(): any;
+    get isMobile(): boolean;
+    private setConstraints;
+    private get activeTrackSettings();
+    private get activeTrackCapabilities();
+    private init;
+    private setup;
+    private startVideo;
+    setCanvas(): 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 stopAllTracks;
     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;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WebcamComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WebcamComponent, "ngx-scandoc-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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WebcamComponent, "ngx-scandoc-webcam", never, { "imageHandler": "imageHandler"; "type": "type"; "trigger": "trigger"; }, { "cameraSwitched": "cameraSwitched"; "videoReady": "videoReady"; "imageCapture": "imageCapture"; "initError": "initError"; }, never, never, false>;
 }

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

@@ -1,8 +1,10 @@
+import { ModuleWithProviders } from '@angular/core';
 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 forRoot(): ModuleWithProviders<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/interfaces/config.d.ts

@@ -4,6 +4,7 @@ export interface AuthConfig {
     clientId: string;
     login?: string;
     refresh?: string;
+    version?: string;
     validDomains?: string[];
 }
 export interface ScanConfig {
@@ -13,6 +14,9 @@ export interface ScanConfig {
     stateLessPath: string;
     development?: boolean;
     hideResults?: boolean;
+    enableVerification: boolean;
+    manualScanDelay: number;
+    showManualMode?: boolean;
 }
 export interface ScanDataConfig {
     auth: AuthConfig;

package/dialogs/components/prompt-manual/prompt-manual.component.d.ts

@@ -0,0 +1,12 @@
+import { OnInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class PromptManualComponent implements OnInit {
+    dialogRef: MatDialogRef<PromptManualComponent>;
+    data: any;
+    constructor(dialogRef: MatDialogRef<PromptManualComponent>, data: any);
+    ngOnInit(): void;
+    close(key: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromptManualComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PromptManualComponent, "app-prompt-manual", never, {}, {}, never, never, false>;
+}

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

@@ -2,13 +2,18 @@ import { AfterViewInit, OnDestroy } from '@angular/core';
 import { MatDialogRef } from '@angular/material/dialog';
 import { BaseComponent } from '../../../core/components/base.component';
 import { DialogsCoreProvider } from '../../../dialogs/dialogs.core.provider';
+import { NgxScandocCameraProvider } from '../../../providers/camera.provider';
+import { Platform } from '@angular/cdk/platform';
 import * as i0 from "@angular/core";
 export declare class ScanProfileComponent extends BaseComponent implements AfterViewInit, OnDestroy {
     dialogs: DialogsCoreProvider;
+    cameraProvider: NgxScandocCameraProvider;
     dialogRef: MatDialogRef<ScanProfileComponent>;
+    private platform;
     type: string;
     showDialog: boolean;
-    constructor(dialogs: DialogsCoreProvider, dialogRef: MatDialogRef<ScanProfileComponent>);
+    handleTouchMove(event: any): void;
+    constructor(dialogs: DialogsCoreProvider, cameraProvider: NgxScandocCameraProvider, dialogRef: MatDialogRef<ScanProfileComponent>, platform: Platform);
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     actions(event: any): void;

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

@@ -1,83 +1,37 @@
-import { EventEmitter, ElementRef, ChangeDetectorRef, AfterViewInit } from '@angular/core';
+import { EventEmitter, ChangeDetectorRef, AfterViewInit, OnDestroy } from '@angular/core';
 import { MatDialogRef } from '@angular/material/dialog';
-import { Subject, Observable } from 'rxjs';
+import { Subject } 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 { NgxScandocCameraProvider } from '../../../providers/camera.provider';
 import { DialogsCoreProvider } from '../../../dialogs/dialogs.core.provider';
-import { TranslateService } from '@ngx-translate/core';
 import { ScanProvider } from '../../../providers/scan.provider';
+import { BaseComponent } from '../../../core/components/base.component';
 import * as i0 from "@angular/core";
-export interface IWindow extends Window {
-    TextDetector: any;
-}
-export declare class ScanSelfieComponent implements AfterViewInit {
+export declare class ScanSelfieComponent extends BaseComponent implements AfterViewInit, OnDestroy {
     cd: ChangeDetectorRef;
+    dialogRef: MatDialogRef<ScanSelfieComponent>;
+    cameraProvider: NgxScandocCameraProvider;
     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;
+    preview: 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;
+    webcamImage: any;
+    constructor(cd: ChangeDetectorRef, dialogRef: MatDialogRef<ScanSelfieComponent>, cameraProvider: NgxScandocCameraProvider, scanProvider: ScanProvider, dialogs: DialogsCoreProvider);
     handleImage(webcamImage: WebcamImage): void;
     handleInitError(error: WebcamInitError): void;
-    get scanBlastCanUpload(): boolean;
-    cameraWasSwitched(deviceId: string): void;
-    get nextWebcamObservable(): Observable<boolean | string>;
+    videoReady(ev: any): void;
     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;
+    ngOnDestroy(): void;
     retry(): void;
-    triggerSnapshot(): void;
     scan(): void;
-    retake(): void;
-    use(): void;
-    selfie(): void;
+    continue(): void;
+    close(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScanSelfieComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScanSelfieComponent, "app-scan-selfie", never, { "type": "type"; }, { "actions": "actions"; }, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScanSelfieComponent, "app-scan-selfie", never, {}, { "actions": "actions"; }, never, never, false>;
 }

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

@@ -12,6 +12,7 @@ export declare class DialogsCoreProvider {
     loading(title?: string): MatDialogRef<BlankComponent, any>;
     alert(title: string, text: string): MatDialogRef<BlankComponent, any>;
     turnDocument(idScan: any): import("rxjs").Observable<any>;
+    promptManual(): import("rxjs").Observable<any>;
     scanSelfie(data: any): MatDialogRef<BlankComponent, any>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DialogsCoreProvider, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DialogsCoreProvider>;