@unissey-web/sdk-angular 3.7.2

package/dist/unissey-sdk/fesm2015/unissey-web-sdk-angular.js

@@ -0,0 +1,1028 @@
+import * as i0 from '@angular/core';
+import { Component, Input, Injectable, ViewEncapsulation, EventEmitter, ChangeDetectionStrategy, Output, ViewChild, NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import '@unissey-web/web-components/dist/button';
+import '@unissey-web/web-components/dist/reference-capture';
+import '@unissey-web/web-components/dist/full-capture';
+import { EN as EN$1, OverlayDisplayMode, AcquisitionPreset, LogLevel } from '@unissey-web/web-components';
+export { AcquisitionPreset, EN, FR, FacingMode, IadMode, OverlayDisplayMode, VideoOrientation, VideoResolutionPreset } from '@unissey-web/web-components';
+import '@unissey-web/web-components/dist/selfie-capture';
+import '@unissey-web/web-components/dist/image-capture-directions';
+import '@unissey-web/web-components/dist/picture-editor';
+import '@unissey-web/web-components/dist/picture-recorder';
+import '@unissey-web/web-components/dist/retry-result';
+import '@unissey-web/web-components/dist/video-record-directions';
+import '@unissey-web/web-components/dist/video-recorder';
+import { CommonModule } from '@angular/common';
+
+class ButtonComponent {
+    constructor() {
+        this.variant = "contained";
+        this.disabled = false;
+        this.width = "auto";
+    }
+}
+ButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ButtonComponent, selector: "unissey-button", inputs: { variant: "variant", disabled: "disabled", width: "width" }, ngImport: i0, template: "<uni-button [disabled]=\"disabled\" [variant]=\"variant\" [width]=\"width\">\n  <div slot=\"icon\">\n    <ng-content select=\"[slot=icon]\"></ng-content>\n  </div>\n  <ng-content></ng-content>\n</uni-button>\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-button",
+                    templateUrl: "./button.component.html",
+                    styleUrls: ["./button.component.css"],
+                }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }] } });
+
+class UnisseySdkService {
+    constructor() { }
+}
+UnisseySdkService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+UnisseySdkService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+// import UnisseySDK, { DSPreset } from "@unissey/sdk-web-js";
+class UnisseySdkComponent {
+    // @Input() dsPreset?: DSPreset;
+    constructor() { }
+    ngOnInit() { }
+    ngOnChanges() { }
+    ngOnDestroy() { }
+}
+UnisseySdkComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+UnisseySdkComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: UnisseySdkComponent, selector: "unissey-widget", usesOnChanges: true, ngImport: i0, template: ` <p>unissey-sdk works!</p> `, isInline: true, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-widget",
+                    template: ` <p>unissey-sdk works!</p> `,
+                    styles: [],
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class ReferenceCaptureComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.recorderOptions = {};
+        this.strings = {};
+        this.hideCaptureBtn = false;
+        this.reference = new EventEmitter();
+        this.recorderReady = new EventEmitter();
+        this.recordStarting = new EventEmitter();
+        this.recordCapturing = new EventEmitter();
+        this.recordInterrupted = new EventEmitter();
+        this.recordCompleted = new EventEmitter();
+    }
+    /**
+     * @internal
+     */
+    ngOnInit() {
+        this.stringifiedStrings = JSON.stringify(this.strings);
+        this.stringifiedRecorderOptions = JSON.stringify(this.recorderOptions);
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.stringifiedStrings = JSON.stringify(changes.strings.currentValue);
+        }
+        if (changes.recorderOptions && !changes.recorderOptions.firstChange) {
+            this.stringifiedRecorderOptions = JSON.stringify(changes.recorderOptions.currentValue);
+        }
+    }
+    /**
+     * @internal
+     */
+    onReference(event) {
+        const { media } = event.detail;
+        this.reference.emit({ media });
+    }
+    /**
+     * @internal
+     */
+    onRecorderReady(event) {
+        this.recorderReady.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordStarting(event) {
+        this.recordStarting.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordCapturing(event) {
+        this.recordCapturing.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordInterrupted(event) {
+        this.recordInterrupted.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordCompleted(event) {
+        this.recordCompleted.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.referenceUnlistenFct = this.renderer.listen(this.referenceRef.nativeElement, "reference", this.onReference.bind(this));
+        this.recorderReadyUnlistenFct = this.renderer.listen(this.referenceRef.nativeElement, "recorderReady", this.onRecorderReady.bind(this));
+        this.recordStartingUnlistenFct = this.renderer.listen(this.referenceRef.nativeElement, "recordStarting", this.onRecordStarting.bind(this));
+        this.recordCapturingUnlistenFct = this.renderer.listen(this.referenceRef.nativeElement, "recordCapturing", this.onRecordCapturing.bind(this));
+        this.recordInterruptedUnlistenFct = this.renderer.listen(this.referenceRef.nativeElement, "recordInterrupted", this.onRecordInterrupted.bind(this));
+        this.recordCompletedUnlistenFct = this.renderer.listen(this.referenceRef.nativeElement, "recordCompleted", this.onRecordCompleted.bind(this));
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        if (this.referenceUnlistenFct) {
+            this.referenceUnlistenFct();
+        }
+        if (this.recorderReadyUnlistenFct) {
+            this.recorderReadyUnlistenFct();
+        }
+        if (this.recordStartingUnlistenFct) {
+            this.recordStartingUnlistenFct();
+        }
+        if (this.recordCapturingUnlistenFct) {
+            this.recordCapturingUnlistenFct();
+        }
+        if (this.recordInterruptedUnlistenFct) {
+            this.recordInterruptedUnlistenFct();
+        }
+        if (this.recordCompletedUnlistenFct) {
+            this.recordCompletedUnlistenFct();
+        }
+    }
+}
+ReferenceCaptureComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReferenceCaptureComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+ReferenceCaptureComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ReferenceCaptureComponent, selector: "unissey-reference-capture", inputs: { recorderOptions: "recorderOptions", strings: "strings", hideCaptureBtn: "hideCaptureBtn" }, outputs: { reference: "reference", recorderReady: "recorderReady", recordStarting: "recordStarting", recordCapturing: "recordCapturing", recordInterrupted: "recordInterrupted", recordCompleted: "recordCompleted" }, viewQueries: [{ propertyName: "referenceRef", first: true, predicate: ["reference"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<uni-reference-capture\n  #reference\n  [attr.strings]=\"stringifiedStrings\"\n  [attr.recorder-options]=\"stringifiedRecorderOptions\"\n  [attr.hide-capture-btn]=\"hideCaptureBtn === true ? true : null\"\n>\n  <ng-content></ng-content>\n</uni-reference-capture>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReferenceCaptureComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-reference-capture",
+                    templateUrl: "./reference-capture.component.html",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { recorderOptions: [{
+                type: Input
+            }], strings: [{
+                type: Input
+            }], hideCaptureBtn: [{
+                type: Input
+            }], reference: [{
+                type: Output
+            }], recorderReady: [{
+                type: Output
+            }], recordStarting: [{
+                type: Output
+            }], recordCapturing: [{
+                type: Output
+            }], recordInterrupted: [{
+                type: Output
+            }], recordCompleted: [{
+                type: Output
+            }], referenceRef: [{
+                type: ViewChild,
+                args: ["reference"]
+            }] } });
+
+class FullCaptureComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.strings = {};
+        this.recorderOptions = {};
+        this.hideReferenceCaptureBtn = false;
+        this.hideSelfieCaptureBtn = false;
+        this.data = new EventEmitter();
+        this.recorderReady = new EventEmitter();
+    }
+    /**
+     * @internal
+     */
+    ngOnInit() {
+        this.stringifiedStrings = JSON.stringify(this.strings);
+        this.stringifiedRecorderOptions = JSON.stringify(this.recorderOptions);
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.stringifiedStrings = JSON.stringify(changes.strings.currentValue);
+        }
+        if (changes.recorderOptions && !changes.recorderOptions.firstChange) {
+            this.stringifiedRecorderOptions = JSON.stringify(changes.recorderOptions.currentValue);
+        }
+    }
+    /**
+     * @internal
+     */
+    onData(event) {
+        this.data.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecorderReady(event) {
+        this.recorderReady.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.fullCaptureUnlistenFct = this.renderer.listen(this.fullCaptureRef.nativeElement, "data", this.onData.bind(this));
+        this.recorderReadyUnlistenFct = this.renderer.listen(this.fullCaptureRef.nativeElement, "recorderReady", this.onRecorderReady.bind(this));
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        if (this.fullCaptureUnlistenFct) {
+            this.fullCaptureUnlistenFct();
+        }
+        if (this.recorderReadyUnlistenFct) {
+            this.recorderReadyUnlistenFct();
+        }
+    }
+}
+FullCaptureComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FullCaptureComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+FullCaptureComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FullCaptureComponent, selector: "unissey-full-capture", inputs: { strings: "strings", recorderOptions: "recorderOptions", hideReferenceCaptureBtn: "hideReferenceCaptureBtn", hideSelfieCaptureBtn: "hideSelfieCaptureBtn" }, outputs: { data: "data", recorderReady: "recorderReady" }, viewQueries: [{ propertyName: "fullCaptureRef", first: true, predicate: ["fullCapture"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<uni-full-capture\n  #fullCapture\n  [attr.strings]=\"stringifiedStrings\"\n  [attr.recorder-options]=\"stringifiedRecorderOptions\"\n  [attr.hide-selfie-capture-btn]=\"hideSelfieCaptureBtn === true ? true : null\"\n  [attr.hide-reference-capture-btn]=\"hideReferenceCaptureBtn === true ? true : null\"\n>\n  <ng-content></ng-content>\n</uni-full-capture>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FullCaptureComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-full-capture",
+                    templateUrl: "./full-capture.component.html",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { strings: [{
+                type: Input
+            }], recorderOptions: [{
+                type: Input
+            }], hideReferenceCaptureBtn: [{
+                type: Input
+            }], hideSelfieCaptureBtn: [{
+                type: Input
+            }], data: [{
+                type: Output
+            }], recorderReady: [{
+                type: Output
+            }], fullCaptureRef: [{
+                type: ViewChild,
+                args: ["fullCapture"]
+            }] } });
+
+class SelfieCaptureComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.strings = EN$1.selfieCapture;
+        this.recorderOptions = {};
+        this.hideCapturePrevBtn = false;
+        this.hideCaptureBtn = false;
+        this.selfie = new EventEmitter();
+        this.recorderReady = new EventEmitter();
+        this.recordStarting = new EventEmitter();
+        this.recordCapturing = new EventEmitter();
+        this.recordInterrupted = new EventEmitter();
+        this.recordCompleted = new EventEmitter();
+    }
+    /**
+     * @internal
+     */
+    ngOnInit() {
+        this.stringifiedStrings = JSON.stringify(this.strings);
+        this.stringifiedRecorderOptions = JSON.stringify(this.recorderOptions);
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.stringifiedStrings = JSON.stringify(changes.strings.currentValue);
+        }
+        if (changes.recorderOptions && !changes.recorderOptions.firstChange) {
+            this.stringifiedRecorderOptions = JSON.stringify(changes.recorderOptions.currentValue);
+        }
+    }
+    /**
+     * @internal
+     */
+    onSelfie(event) {
+        const { media, metadata } = event.detail;
+        this.selfie.emit({ media, metadata });
+    }
+    /**
+     * @internal
+     */
+    onRecorderReady(event) {
+        this.recorderReady.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordStarting(event) {
+        this.recordStarting.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordCapturing(event) {
+        this.recordCapturing.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordInterrupted(event) {
+        this.recordInterrupted.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordCompleted(event) {
+        this.recordCompleted.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.selfieUnlistenFct = this.renderer.listen(this.selfieRef.nativeElement, "selfie", this.onSelfie.bind(this));
+        this.recorderReadyUnlistenFct = this.renderer.listen(this.selfieRef.nativeElement, "recorderReady", this.onRecorderReady.bind(this));
+        this.recordStartingUnlistenFct = this.renderer.listen(this.selfieRef.nativeElement, "recordStarting", this.onRecordStarting.bind(this));
+        this.recordCapturingUnlistenFct = this.renderer.listen(this.selfieRef.nativeElement, "recordCapturing", this.onRecordCapturing.bind(this));
+        this.recordInterruptedUnlistenFct = this.renderer.listen(this.selfieRef.nativeElement, "recordInterrupted", this.onRecordInterrupted.bind(this));
+        this.recordCompletedUnlistenFct = this.renderer.listen(this.selfieRef.nativeElement, "recordCompleted", this.onRecordCompleted.bind(this));
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        if (this.selfieUnlistenFct) {
+            this.selfieUnlistenFct();
+        }
+        if (this.recorderReadyUnlistenFct) {
+            this.recorderReadyUnlistenFct();
+        }
+        if (this.recordStartingUnlistenFct) {
+            this.recordStartingUnlistenFct();
+        }
+        if (this.recordCapturingUnlistenFct) {
+            this.recordCapturingUnlistenFct();
+        }
+        if (this.recordInterruptedUnlistenFct) {
+            this.recordInterruptedUnlistenFct();
+        }
+        if (this.recordCompletedUnlistenFct) {
+            this.recordCompletedUnlistenFct();
+        }
+    }
+}
+SelfieCaptureComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelfieCaptureComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+SelfieCaptureComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: SelfieCaptureComponent, selector: "unissey-selfie-capture", inputs: { strings: "strings", recorderOptions: "recorderOptions", hideCapturePrevBtn: "hideCapturePrevBtn", hideCaptureBtn: "hideCaptureBtn" }, outputs: { selfie: "selfie", recorderReady: "recorderReady", recordStarting: "recordStarting", recordCapturing: "recordCapturing", recordInterrupted: "recordInterrupted", recordCompleted: "recordCompleted" }, viewQueries: [{ propertyName: "selfieRef", first: true, predicate: ["selfie"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<uni-selfie-capture\n  #selfie\n  [attr.strings]=\"stringifiedStrings\"\n  [attr.recorder-options]=\"stringifiedRecorderOptions\"\n  [attr.hide-capture-prev-btn]=\"hideCapturePrevBtn === true ? true : null\"\n  [attr.hide-capture-btn]=\"hideCaptureBtn === true ? true : null\"\n>\n  <ng-content></ng-content>\n</uni-selfie-capture>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelfieCaptureComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-selfie-capture",
+                    templateUrl: "./selfie.component.html",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { strings: [{
+                type: Input
+            }], recorderOptions: [{
+                type: Input
+            }], hideCapturePrevBtn: [{
+                type: Input
+            }], hideCaptureBtn: [{
+                type: Input
+            }], selfie: [{
+                type: Output
+            }], recorderReady: [{
+                type: Output
+            }], recordStarting: [{
+                type: Output
+            }], recordCapturing: [{
+                type: Output
+            }], recordInterrupted: [{
+                type: Output
+            }], recordCompleted: [{
+                type: Output
+            }], selfieRef: [{
+                type: ViewChild,
+                args: ["selfie"]
+            }] } });
+
+const EN = Object.assign({ targetCapture: {
+        back: "Back",
+        directionSubtitle: "Let's make sure no one's impersonating you",
+        recordBtnLabel: "Record a video",
+        title: "Record a short video selfie",
+        recordSubtitle: "The acquisition will last 1 second",
+        directions: Object.assign({}, EN$1.videoRecordDirections),
+        recorder: Object.assign({}, EN$1.videoRecorder),
+    } }, EN$1);
+
+class ImageCaptureDirectionsComponent {
+    constructor() {
+        this.strings = EN.imageCaptureDirections;
+        this.instructions = "";
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.instructions = JSON.stringify(changes.strings.currentValue);
+        }
+    }
+    ngOnInit() {
+        this.instructions = JSON.stringify(this.strings);
+    }
+}
+ImageCaptureDirectionsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ImageCaptureDirectionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ImageCaptureDirectionsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ImageCaptureDirectionsComponent, selector: "unissey-image-capture-directions", inputs: { strings: "strings" }, usesOnChanges: true, ngImport: i0, template: "<uni-image-capture-directions [attr.strings]=\"instructions\"></uni-image-capture-directions>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ImageCaptureDirectionsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-image-capture-directions",
+                    templateUrl: "./image-capture-directions.component.html",
+                }]
+        }], propDecorators: { strings: [{
+                type: Input
+            }] } });
+
+class PictureEditorComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.image = "";
+        this.strings = EN.pictureEditor;
+        this.validatedImage = new EventEmitter();
+        this.editorStrings = "";
+    }
+    /**
+     * @internal
+     */
+    set element(node) {
+        if (!node) {
+            if (this.validationUnlistenFct) {
+                this.validationUnlistenFct();
+                this.validationUnlistenFct = undefined;
+            }
+            return;
+        }
+        this.validationUnlistenFct = this.renderer.listen(node.nativeElement, "picture", this.pictureValidated.bind(this));
+    }
+    ngOnInit() {
+        this.editorStrings = JSON.stringify(this.strings);
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.editorStrings = JSON.stringify(changes.strings.currentValue);
+        }
+    }
+    ngOnDestroy() {
+        if (this.validationUnlistenFct) {
+            this.validationUnlistenFct();
+        }
+    }
+    /**
+     * @internal
+     */
+    pictureValidated(event) {
+        const { picture } = event.detail;
+        this.validatedImage.emit(picture);
+    }
+}
+PictureEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PictureEditorComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+PictureEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: PictureEditorComponent, selector: "unissey-picture-editor", inputs: { image: "image", strings: "strings" }, outputs: { validatedImage: "validatedImage" }, viewQueries: [{ propertyName: "element", first: true, predicate: ["editor"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<uni-picture-editor #editor [attr.img]=\"image\" [attr.strings]=\"editorStrings\">\n  <div slot=\"cancel\">\n    <ng-content select=\"[slot=actions]\"></ng-content>\n  </div>\n</uni-picture-editor>\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PictureEditorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-picture-editor",
+                    templateUrl: "./picture-editor.component.html",
+                    styleUrls: ["./picture-editor.component.css"],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { image: [{
+                type: Input
+            }], strings: [{
+                type: Input
+            }], validatedImage: [{
+                type: Output
+            }], element: [{
+                type: ViewChild,
+                args: ["editor"]
+            }] } });
+
+class PictureRecorderComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.recorderOverlay = OverlayDisplayMode.ID_DOCUMENT;
+        this.preset = AcquisitionPreset.DOC_IMAGE;
+        this.config = {};
+        this.strings = EN.pictureRecorder;
+        this.displayFlipCameraBtn = undefined;
+        this.hideCaptureBtn = false;
+        this.faceChecker = "disabled";
+        this.logLevel = LogLevel.QUIET;
+        this.picture = new EventEmitter();
+        this.recordStarting = new EventEmitter();
+        this.recordCapturing = new EventEmitter();
+        this.recordInterrupted = new EventEmitter();
+        this.recordCompleted = new EventEmitter();
+        this.recorderStrings = "";
+    }
+    set recorder(node) {
+        if (!node) {
+            if (this.pictureRecUnlistenFct)
+                this.pictureRecUnlistenFct();
+            if (this.recordStartingRecUnlistenFct)
+                this.recordStartingRecUnlistenFct();
+            if (this.recordCapturingRecUnlistenFct)
+                this.recordCapturingRecUnlistenFct();
+            if (this.recordInterruptedRecUnlistenFct)
+                this.recordInterruptedRecUnlistenFct();
+            if (this.recordCompletedRecUnlistenFct)
+                this.recordCompletedRecUnlistenFct();
+            return;
+        }
+        this.pictureRecUnlistenFct = this.renderer.listen(node.nativeElement, "picture", this.pictureRecorded.bind(this));
+        this.recordStartingRecUnlistenFct = this.renderer.listen(node.nativeElement, "recordStarting", this.onRecordStarting.bind(this));
+        this.recordCapturingRecUnlistenFct = this.renderer.listen(node.nativeElement, "recordCapturing", this.onRecordCapturing.bind(this));
+        this.recordInterruptedRecUnlistenFct = this.renderer.listen(node.nativeElement, "recordInterrupted", this.onRecordInterrupted.bind(this));
+        this.recordCompletedRecUnlistenFct = this.renderer.listen(node.nativeElement, "recordCompleted", this.onRecordCompleted.bind(this));
+    }
+    ngOnInit() {
+        this.recorderStrings = JSON.stringify(this.strings);
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.recorderStrings = JSON.stringify(changes.strings.currentValue);
+        }
+    }
+    ngOnDestroy() {
+        if (this.pictureRecUnlistenFct) {
+            this.pictureRecUnlistenFct();
+        }
+    }
+    pictureRecorded(event) {
+        const { picture } = event.detail;
+        if (picture) {
+            this.picture.emit(picture);
+        }
+    }
+    /**
+     * @internal
+     */
+    onRecordStarting(event) {
+        this.recordStarting.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordCapturing(event) {
+        this.recordCapturing.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordInterrupted(event) {
+        this.recordInterrupted.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordCompleted(event) {
+        if (event.detail.picture) {
+            this.recordCompleted.emit(event.detail.picture);
+        }
+    }
+}
+PictureRecorderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PictureRecorderComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+PictureRecorderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: PictureRecorderComponent, selector: "unissey-picture-recorder", inputs: { preset: "preset", config: "config", strings: "strings", displayFlipCameraBtn: "displayFlipCameraBtn", hideCaptureBtn: "hideCaptureBtn", faceChecker: "faceChecker", logLevel: "logLevel" }, outputs: { picture: "picture", recordStarting: "recordStarting", recordCapturing: "recordCapturing", recordInterrupted: "recordInterrupted", recordCompleted: "recordCompleted" }, viewQueries: [{ propertyName: "recorder", first: true, predicate: ["recorder"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<uni-picture-recorder\n  #recorder\n  [attr.preset]=\"preset\"\n  [attr.config]=\"config\"\n  [attr.strings]=\"recorderStrings\"\n  [attr.face-checker]=\"faceChecker\"\n  [attr.overlay-mode]=\"recorderOverlay\"\n  [attr.display-flip-camera-btn]=\"displayFlipCameraBtn === true ? true : null\"\n  [attr.hide-capture-btn]=\"hideCaptureBtn === true ? true : null\"\n  [attr.log-level]=\"logLevel\"\n>\n  <div slot=\"left\">\n    <ng-content select=\"[slot=actions]\"></ng-content>\n  </div>\n</uni-picture-recorder>\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PictureRecorderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-picture-recorder",
+                    templateUrl: "./picture-recorder.component.html",
+                    styleUrls: ["./picture-recorder.component.css"],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { recorder: [{
+                type: ViewChild,
+                args: ["recorder"]
+            }], preset: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], strings: [{
+                type: Input
+            }], displayFlipCameraBtn: [{
+                type: Input
+            }], hideCaptureBtn: [{
+                type: Input
+            }], faceChecker: [{
+                type: Input
+            }], logLevel: [{
+                type: Input
+            }], picture: [{
+                type: Output
+            }], recordStarting: [{
+                type: Output
+            }], recordCapturing: [{
+                type: Output
+            }], recordInterrupted: [{
+                type: Output
+            }], recordCompleted: [{
+                type: Output
+            }] } });
+
+class FileUploadComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.maxSize = 5000000;
+        this.supportedTypes = ["image/png", "image/jpeg", "image/jpg", "image/jp2"];
+        this.strings = EN.fileUpload;
+        this.file = new EventEmitter();
+        this.stringifiedStrings = "";
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.uploaderUnlistenCb = this.renderer.listen(this.uploader.nativeElement, "change", this.emitUploadedFile.bind(this));
+    }
+    ngOnInit() {
+        this.stringifiedStrings = JSON.stringify(this.strings);
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.stringifiedStrings = JSON.stringify(changes.strings.currentValue);
+        }
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        if (this.uploaderUnlistenCb) {
+            this.uploaderUnlistenCb();
+        }
+    }
+    /**
+     * @internal
+     */
+    emitUploadedFile(event) {
+        this.file.emit(event.detail.file);
+    }
+}
+FileUploadComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FileUploadComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+FileUploadComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FileUploadComponent, selector: "unissey-file-upload", inputs: { maxSize: "maxSize", supportedTypes: "supportedTypes", strings: "strings" }, outputs: { file: "file" }, viewQueries: [{ propertyName: "uploader", first: true, predicate: ["uploader"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<uni-file-upload\n  #uploader\n  [attr.max-size]=\"maxSize\"\n  [attr.strings]=\"stringifiedStrings\"\n  [attr.supported-types]=\"supportedTypes\"\n></uni-file-upload>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FileUploadComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-file-upload",
+                    templateUrl: "./file-upload.component.html",
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { uploader: [{
+                type: ViewChild,
+                args: ["uploader"]
+            }], maxSize: [{
+                type: Input
+            }], supportedTypes: [{
+                type: Input
+            }], strings: [{
+                type: Input
+            }], file: [{
+                type: Output
+            }] } });
+
+class RetryResultComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.hint = "generic";
+        this.retriesLeft = 2;
+        this.strings = EN$1.retryResult;
+        this.finish = new EventEmitter();
+        this.retry = new EventEmitter();
+        this.retryStringifiedStrings = "";
+    }
+    set retryView(node) {
+        if (!node) {
+            if (this.onFinishListener) {
+                this.onFinishListener();
+                this.onFinishListener = undefined;
+            }
+            if (this.onRetryListener) {
+                this.onRetryListener();
+                this.onRetryListener = undefined;
+            }
+            return;
+        }
+        this.onFinishListener = this.renderer.listen(node.nativeElement, "finish", this.onFinishEvent.bind(this));
+        this.onRetryListener = this.renderer.listen(node.nativeElement, "retry", this.onRetryEvent.bind(this));
+    }
+    ngOnInit() {
+        this.retryStringifiedStrings = JSON.stringify(this.retryStringifiedStrings);
+    }
+    ngAfterViewInit() {
+        if (this.retryView) {
+            this.onFinishListener = this.renderer.listen(this.retryView.nativeElement, "finish", this.onFinishEvent);
+            this.onRetryListener = this.renderer.listen(this.retryView.nativeElement, "retry", this.onRetryEvent);
+        }
+    }
+    onFinishEvent(_) {
+        this.finish.emit();
+    }
+    onRetryEvent(_) {
+        this.retry.emit();
+    }
+}
+RetryResultComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RetryResultComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+RetryResultComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: RetryResultComponent, selector: "unissey-retry-result", inputs: { hint: "hint", retriesLeft: "retriesLeft", strings: "strings" }, outputs: { finish: "finish", retry: "retry" }, viewQueries: [{ propertyName: "retryView", first: true, predicate: ["retryView"], descendants: true }], ngImport: i0, template: "<uni-retry-result\n  #retryView\n  [attr.retries-left]=\"retriesLeft\"\n  [attr.hint-kind]=\"hint\"\n  [strings]=\"strings\"\n></uni-retry-result>\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RetryResultComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-retry-result",
+                    templateUrl: "./retry-result.component.html",
+                    styleUrls: ["./retry-result.component.css"],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { hint: [{
+                type: Input
+            }], retriesLeft: [{
+                type: Input
+            }], strings: [{
+                type: Input
+            }], finish: [{
+                type: Output
+            }], retry: [{
+                type: Output
+            }], retryView: [{
+                type: ViewChild,
+                args: ["retryView"]
+            }] } });
+
+class VideoCaptureDirectionsComponent {
+    constructor() {
+        this.strings = EN.videoRecordDirections;
+        this.instructions = "";
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.instructions = JSON.stringify(changes.strings.currentValue);
+        }
+    }
+    ngOnInit() {
+        this.instructions = JSON.stringify(this.strings);
+    }
+}
+VideoCaptureDirectionsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VideoCaptureDirectionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+VideoCaptureDirectionsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: VideoCaptureDirectionsComponent, selector: "unissey-video-capture-directions", inputs: { strings: "strings" }, usesOnChanges: true, ngImport: i0, template: "<uni-video-record-directions [attr.strings]=\"instructions\"></uni-video-record-directions>\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VideoCaptureDirectionsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-video-capture-directions",
+                    templateUrl: "./video-capture-directions.component.html",
+                    styleUrls: ["./video-capture-directions.component.css"],
+                }]
+        }], propDecorators: { strings: [{
+                type: Input
+            }] } });
+
+class VideoRecorderComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.strings = EN.videoRecorder;
+        this.preset = AcquisitionPreset.SELFIE_FAST;
+        this.config = {};
+        this.instructionMessages = [];
+        this.faceChecker = "disabled-on-retry";
+        this.displayFlipCameraBtn = false;
+        this.hideCaptureBtn = false;
+        this.logLevel = LogLevel.QUIET;
+        this.record = new EventEmitter();
+        this.recorderReady = new EventEmitter();
+        this.recordStarting = new EventEmitter();
+        this.recordCapturing = new EventEmitter();
+        this.recordInterrupted = new EventEmitter();
+        this.recordCompleted = new EventEmitter();
+        this.issue = new EventEmitter();
+    }
+    /**
+     * @internal
+     */
+    ngOnInit() {
+        this.stringifiedStrings = JSON.stringify(this.strings);
+        this.stringifiedInstructionMessages = JSON.stringify(this.instructionMessages);
+        this.stringifiedConfig = JSON.stringify(this.config);
+    }
+    ngOnChanges(changes) {
+        if (changes.strings && !changes.strings.firstChange) {
+            this.stringifiedStrings = JSON.stringify(changes.strings.currentValue);
+        }
+        if (changes.config && !changes.config.firstChange) {
+            this.stringifiedConfig = JSON.stringify(changes.config.currentValue);
+        }
+        if (changes.instructionMessages && !changes.instructionMessages.firstChange) {
+            this.stringifiedInstructionMessages = JSON.stringify(changes.instructionMessages.currentValue);
+        }
+    }
+    /**
+     * @internal
+     */
+    onRecord(event) {
+        this.record.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecorderReady(event) {
+        this.recorderReady.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordStarting(event) {
+        this.recordStarting.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordCapturing(event) {
+        this.recordCapturing.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordInterrupted(event) {
+        this.recordInterrupted.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordCompleted(event) {
+        this.recordCompleted.emit(event.detail);
+    }
+    /**
+     * @internal
+     */
+    onRecordIssue(event) {
+        this.issue.emit(event.detail.issueType);
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.recorderUnlistenFct = this.renderer.listen(this.recorderRef.nativeElement, "record", this.onRecord.bind(this));
+        this.issueUnlistenFct = this.renderer.listen(this.recorderRef.nativeElement, "issue", this.onRecordIssue.bind(this));
+        this.recorderReadyUnlistenFct = this.renderer.listen(this.recorderRef.nativeElement, "recorderReady", this.onRecorderReady.bind(this));
+        this.recordStartingUnlistenFct = this.renderer.listen(this.recorderRef.nativeElement, "recordStarting", this.onRecordStarting.bind(this));
+        this.recordCapturingUnlistenFct = this.renderer.listen(this.recorderRef.nativeElement, "recordCapturing", this.onRecordCapturing.bind(this));
+        this.recordInterruptedUnlistenFct = this.renderer.listen(this.recorderRef.nativeElement, "recordInterrupted", this.onRecordInterrupted.bind(this));
+        this.recordCompletedUnlistenFct = this.renderer.listen(this.recorderRef.nativeElement, "recordCompleted", this.onRecordCompleted.bind(this));
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        if (this.recorderUnlistenFct) {
+            this.recorderUnlistenFct();
+        }
+        if (this.issueUnlistenFct) {
+            this.issueUnlistenFct();
+        }
+        if (this.recorderReadyUnlistenFct) {
+            this.recorderReadyUnlistenFct();
+        }
+        if (this.recordStartingUnlistenFct) {
+            this.recordStartingUnlistenFct();
+        }
+        if (this.recordCapturingUnlistenFct) {
+            this.recordCapturingUnlistenFct();
+        }
+        if (this.recordInterruptedUnlistenFct) {
+            this.recordInterruptedUnlistenFct();
+        }
+        if (this.recordCompletedUnlistenFct) {
+            this.recordCompletedUnlistenFct();
+        }
+    }
+}
+VideoRecorderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VideoRecorderComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+VideoRecorderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: VideoRecorderComponent, selector: "unissey-video-recorder", inputs: { strings: "strings", preset: "preset", config: "config", instructionMessages: "instructionMessages", faceChecker: "faceChecker", displayFlipCameraBtn: "displayFlipCameraBtn", hideCaptureBtn: "hideCaptureBtn", logLevel: "logLevel" }, outputs: { record: "record", recorderReady: "recorderReady", recordStarting: "recordStarting", recordCapturing: "recordCapturing", recordInterrupted: "recordInterrupted", recordCompleted: "recordCompleted", issue: "issue" }, viewQueries: [{ propertyName: "recorderRef", first: true, predicate: ["camera"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<uni-video-recorder\n  #camera\n  [attr.preset]=\"preset\"\n  [attr.strings]=\"stringifiedStrings\"\n  [attr.face-checker]=\"faceChecker\"\n  [attr.config]=\"stringifiedConfig\"\n  [attr.instruction-messages]=\"stringifiedInstructionMessages\"\n  [attr.display-flip-camera-btn]=\"displayFlipCameraBtn === true ? true : null\"\n  [attr.hide-capture-btn]=\"hideCaptureBtn === true ? true : null\"\n  [attr.log-level]=\"logLevel\"\n>\n  <div slot=\"left\">\n    <ng-content select=\"[slot=actions]\"></ng-content>\n  </div>\n</uni-video-recorder>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: VideoRecorderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "unissey-video-recorder",
+                    templateUrl: "./video-recorder.component.html",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { strings: [{
+                type: Input
+            }], preset: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], instructionMessages: [{
+                type: Input
+            }], faceChecker: [{
+                type: Input
+            }], displayFlipCameraBtn: [{
+                type: Input
+            }], hideCaptureBtn: [{
+                type: Input
+            }], logLevel: [{
+                type: Input
+            }], record: [{
+                type: Output
+            }], recorderReady: [{
+                type: Output
+            }], recordStarting: [{
+                type: Output
+            }], recordCapturing: [{
+                type: Output
+            }], recordInterrupted: [{
+                type: Output
+            }], recordCompleted: [{
+                type: Output
+            }], issue: [{
+                type: Output
+            }], recorderRef: [{
+                type: ViewChild,
+                args: ["camera"]
+            }] } });
+
+class UnisseySdkModule {
+}
+UnisseySdkModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+UnisseySdkModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkModule, declarations: [ButtonComponent,
+        FileUploadComponent,
+        FullCaptureComponent,
+        SelfieCaptureComponent,
+        ImageCaptureDirectionsComponent,
+        PictureEditorComponent,
+        PictureRecorderComponent,
+        ReferenceCaptureComponent,
+        RetryResultComponent,
+        VideoCaptureDirectionsComponent,
+        VideoRecorderComponent,
+        UnisseySdkComponent], imports: [CommonModule], exports: [ButtonComponent,
+        FileUploadComponent,
+        FullCaptureComponent,
+        SelfieCaptureComponent,
+        ImageCaptureDirectionsComponent,
+        PictureEditorComponent,
+        PictureRecorderComponent,
+        ReferenceCaptureComponent,
+        RetryResultComponent,
+        VideoCaptureDirectionsComponent,
+        VideoRecorderComponent,
+        UnisseySdkComponent] });
+UnisseySdkModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UnisseySdkModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ButtonComponent,
+                        FileUploadComponent,
+                        FullCaptureComponent,
+                        SelfieCaptureComponent,
+                        ImageCaptureDirectionsComponent,
+                        PictureEditorComponent,
+                        PictureRecorderComponent,
+                        ReferenceCaptureComponent,
+                        RetryResultComponent,
+                        VideoCaptureDirectionsComponent,
+                        VideoRecorderComponent,
+                        UnisseySdkComponent,
+                    ],
+                    imports: [CommonModule],
+                    exports: [
+                        ButtonComponent,
+                        FileUploadComponent,
+                        FullCaptureComponent,
+                        SelfieCaptureComponent,
+                        ImageCaptureDirectionsComponent,
+                        PictureEditorComponent,
+                        PictureRecorderComponent,
+                        ReferenceCaptureComponent,
+                        RetryResultComponent,
+                        VideoCaptureDirectionsComponent,
+                        VideoRecorderComponent,
+                        UnisseySdkComponent,
+                    ],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }] });
+
+/*
+ * Public API Surface of @unissey-web/sdk-angular
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ButtonComponent, FileUploadComponent, FullCaptureComponent, ImageCaptureDirectionsComponent, PictureEditorComponent, PictureRecorderComponent, ReferenceCaptureComponent, RetryResultComponent, SelfieCaptureComponent, UnisseySdkComponent, UnisseySdkModule, UnisseySdkService, VideoCaptureDirectionsComponent, VideoRecorderComponent };
+//# sourceMappingURL=unissey-web-sdk-angular.js.map