@unissey-web/sdk-angular 3.7.2

package/dist/unissey-sdk/bundles/unissey-web-sdk-angular.umd.js

@@ -0,0 +1,1117 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@unissey-web/web-components/dist/button'), require('@unissey-web/web-components/dist/reference-capture'), require('@unissey-web/web-components/dist/full-capture'), require('@unissey-web/web-components'), require('@unissey-web/web-components/dist/selfie-capture'), require('@unissey-web/web-components/dist/image-capture-directions'), require('@unissey-web/web-components/dist/picture-editor'), require('@unissey-web/web-components/dist/picture-recorder'), require('@unissey-web/web-components/dist/retry-result'), require('@unissey-web/web-components/dist/video-record-directions'), require('@unissey-web/web-components/dist/video-recorder'), require('@angular/common')) :
+    typeof define === 'function' && define.amd ? define('@unissey-web/sdk-angular', ['exports', '@angular/core', '@unissey-web/web-components/dist/button', '@unissey-web/web-components/dist/reference-capture', '@unissey-web/web-components/dist/full-capture', '@unissey-web/web-components', '@unissey-web/web-components/dist/selfie-capture', '@unissey-web/web-components/dist/image-capture-directions', '@unissey-web/web-components/dist/picture-editor', '@unissey-web/web-components/dist/picture-recorder', '@unissey-web/web-components/dist/retry-result', '@unissey-web/web-components/dist/video-record-directions', '@unissey-web/web-components/dist/video-recorder', '@angular/common'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global["unissey-web"] = global["unissey-web"] || {}, global["unissey-web"]["sdk-angular"] = {}), global.ng.core, null, null, null, global["@unissey-web/web-components"], null, null, null, null, null, null, null, global.ng.common));
+})(this, (function (exports, i0, button, referenceCapture, fullCapture, webComponents, selfieCapture, imageCaptureDirections, pictureEditor, pictureRecorder, retryResult, videoRecordDirections, videoRecorder, common) { 'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n["default"] = e;
+        return Object.freeze(n);
+    }
+
+    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+
+    var ButtonComponent = /** @class */ (function () {
+        function ButtonComponent() {
+            this.variant = "contained";
+            this.disabled = false;
+            this.width = "auto";
+        }
+        return ButtonComponent;
+    }());
+    ButtonComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: ButtonComponent, deps: [], target: i0__namespace.ɵɵFactoryTarget.Component });
+    ButtonComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ButtonComponent, selector: "unissey-button", inputs: { variant: "variant", disabled: "disabled", width: "width" }, ngImport: i0__namespace, 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__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: ButtonComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-button",
+                        templateUrl: "./button.component.html",
+                        styleUrls: ["./button.component.css"],
+                    }]
+            }], propDecorators: { variant: [{
+                    type: i0.Input
+                }], disabled: [{
+                    type: i0.Input
+                }], width: [{
+                    type: i0.Input
+                }] } });
+
+    var UnisseySdkService = /** @class */ (function () {
+        function UnisseySdkService() {
+        }
+        return UnisseySdkService;
+    }());
+    UnisseySdkService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkService, deps: [], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    UnisseySdkService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }], ctorParameters: function () { return []; } });
+
+    // import UnisseySDK, { DSPreset } from "@unissey/sdk-web-js";
+    var UnisseySdkComponent = /** @class */ (function () {
+        // @Input() dsPreset?: DSPreset;
+        function UnisseySdkComponent() {
+        }
+        UnisseySdkComponent.prototype.ngOnInit = function () { };
+        UnisseySdkComponent.prototype.ngOnChanges = function () { };
+        UnisseySdkComponent.prototype.ngOnDestroy = function () { };
+        return UnisseySdkComponent;
+    }());
+    UnisseySdkComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkComponent, deps: [], target: i0__namespace.ɵɵFactoryTarget.Component });
+    UnisseySdkComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: UnisseySdkComponent, selector: "unissey-widget", usesOnChanges: true, ngImport: i0__namespace, template: " <p>unissey-sdk works!</p> ", isInline: true, encapsulation: i0__namespace.ViewEncapsulation.None });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-widget",
+                        template: " <p>unissey-sdk works!</p> ",
+                        styles: [],
+                        encapsulation: i0.ViewEncapsulation.None,
+                    }]
+            }], ctorParameters: function () { return []; } });
+
+    var ReferenceCaptureComponent = /** @class */ (function () {
+        function ReferenceCaptureComponent(renderer) {
+            this.renderer = renderer;
+            this.recorderOptions = {};
+            this.strings = {};
+            this.hideCaptureBtn = false;
+            this.reference = new i0.EventEmitter();
+            this.recorderReady = new i0.EventEmitter();
+            this.recordStarting = new i0.EventEmitter();
+            this.recordCapturing = new i0.EventEmitter();
+            this.recordInterrupted = new i0.EventEmitter();
+            this.recordCompleted = new i0.EventEmitter();
+        }
+        /**
+         * @internal
+         */
+        ReferenceCaptureComponent.prototype.ngOnInit = function () {
+            this.stringifiedStrings = JSON.stringify(this.strings);
+            this.stringifiedRecorderOptions = JSON.stringify(this.recorderOptions);
+        };
+        ReferenceCaptureComponent.prototype.ngOnChanges = function (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
+         */
+        ReferenceCaptureComponent.prototype.onReference = function (event) {
+            var media = event.detail.media;
+            this.reference.emit({ media: media });
+        };
+        /**
+         * @internal
+         */
+        ReferenceCaptureComponent.prototype.onRecorderReady = function (event) {
+            this.recorderReady.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        ReferenceCaptureComponent.prototype.onRecordStarting = function (event) {
+            this.recordStarting.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        ReferenceCaptureComponent.prototype.onRecordCapturing = function (event) {
+            this.recordCapturing.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        ReferenceCaptureComponent.prototype.onRecordInterrupted = function (event) {
+            this.recordInterrupted.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        ReferenceCaptureComponent.prototype.onRecordCompleted = function (event) {
+            this.recordCompleted.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        ReferenceCaptureComponent.prototype.ngAfterViewInit = function () {
+            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
+         */
+        ReferenceCaptureComponent.prototype.ngOnDestroy = function () {
+            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();
+            }
+        };
+        return ReferenceCaptureComponent;
+    }());
+    ReferenceCaptureComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: ReferenceCaptureComponent, deps: [{ token: i0__namespace.Renderer2 }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    ReferenceCaptureComponent.ɵcmp = i0__namespace.ɵɵ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__namespace, 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__namespace.ChangeDetectionStrategy.OnPush });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: ReferenceCaptureComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-reference-capture",
+                        templateUrl: "./reference-capture.component.html",
+                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.Renderer2 }]; }, propDecorators: { recorderOptions: [{
+                    type: i0.Input
+                }], strings: [{
+                    type: i0.Input
+                }], hideCaptureBtn: [{
+                    type: i0.Input
+                }], reference: [{
+                    type: i0.Output
+                }], recorderReady: [{
+                    type: i0.Output
+                }], recordStarting: [{
+                    type: i0.Output
+                }], recordCapturing: [{
+                    type: i0.Output
+                }], recordInterrupted: [{
+                    type: i0.Output
+                }], recordCompleted: [{
+                    type: i0.Output
+                }], referenceRef: [{
+                    type: i0.ViewChild,
+                    args: ["reference"]
+                }] } });
+
+    var FullCaptureComponent = /** @class */ (function () {
+        function FullCaptureComponent(renderer) {
+            this.renderer = renderer;
+            this.strings = {};
+            this.recorderOptions = {};
+            this.hideReferenceCaptureBtn = false;
+            this.hideSelfieCaptureBtn = false;
+            this.data = new i0.EventEmitter();
+            this.recorderReady = new i0.EventEmitter();
+        }
+        /**
+         * @internal
+         */
+        FullCaptureComponent.prototype.ngOnInit = function () {
+            this.stringifiedStrings = JSON.stringify(this.strings);
+            this.stringifiedRecorderOptions = JSON.stringify(this.recorderOptions);
+        };
+        FullCaptureComponent.prototype.ngOnChanges = function (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
+         */
+        FullCaptureComponent.prototype.onData = function (event) {
+            this.data.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        FullCaptureComponent.prototype.onRecorderReady = function (event) {
+            this.recorderReady.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        FullCaptureComponent.prototype.ngAfterViewInit = function () {
+            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
+         */
+        FullCaptureComponent.prototype.ngOnDestroy = function () {
+            if (this.fullCaptureUnlistenFct) {
+                this.fullCaptureUnlistenFct();
+            }
+            if (this.recorderReadyUnlistenFct) {
+                this.recorderReadyUnlistenFct();
+            }
+        };
+        return FullCaptureComponent;
+    }());
+    FullCaptureComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: FullCaptureComponent, deps: [{ token: i0__namespace.Renderer2 }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    FullCaptureComponent.ɵcmp = i0__namespace.ɵɵ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__namespace, 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__namespace.ChangeDetectionStrategy.OnPush });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: FullCaptureComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-full-capture",
+                        templateUrl: "./full-capture.component.html",
+                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.Renderer2 }]; }, propDecorators: { strings: [{
+                    type: i0.Input
+                }], recorderOptions: [{
+                    type: i0.Input
+                }], hideReferenceCaptureBtn: [{
+                    type: i0.Input
+                }], hideSelfieCaptureBtn: [{
+                    type: i0.Input
+                }], data: [{
+                    type: i0.Output
+                }], recorderReady: [{
+                    type: i0.Output
+                }], fullCaptureRef: [{
+                    type: i0.ViewChild,
+                    args: ["fullCapture"]
+                }] } });
+
+    var SelfieCaptureComponent = /** @class */ (function () {
+        function SelfieCaptureComponent(renderer) {
+            this.renderer = renderer;
+            this.strings = webComponents.EN.selfieCapture;
+            this.recorderOptions = {};
+            this.hideCapturePrevBtn = false;
+            this.hideCaptureBtn = false;
+            this.selfie = new i0.EventEmitter();
+            this.recorderReady = new i0.EventEmitter();
+            this.recordStarting = new i0.EventEmitter();
+            this.recordCapturing = new i0.EventEmitter();
+            this.recordInterrupted = new i0.EventEmitter();
+            this.recordCompleted = new i0.EventEmitter();
+        }
+        /**
+         * @internal
+         */
+        SelfieCaptureComponent.prototype.ngOnInit = function () {
+            this.stringifiedStrings = JSON.stringify(this.strings);
+            this.stringifiedRecorderOptions = JSON.stringify(this.recorderOptions);
+        };
+        SelfieCaptureComponent.prototype.ngOnChanges = function (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
+         */
+        SelfieCaptureComponent.prototype.onSelfie = function (event) {
+            var _a = event.detail, media = _a.media, metadata = _a.metadata;
+            this.selfie.emit({ media: media, metadata: metadata });
+        };
+        /**
+         * @internal
+         */
+        SelfieCaptureComponent.prototype.onRecorderReady = function (event) {
+            this.recorderReady.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        SelfieCaptureComponent.prototype.onRecordStarting = function (event) {
+            this.recordStarting.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        SelfieCaptureComponent.prototype.onRecordCapturing = function (event) {
+            this.recordCapturing.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        SelfieCaptureComponent.prototype.onRecordInterrupted = function (event) {
+            this.recordInterrupted.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        SelfieCaptureComponent.prototype.onRecordCompleted = function (event) {
+            this.recordCompleted.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        SelfieCaptureComponent.prototype.ngAfterViewInit = function () {
+            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
+         */
+        SelfieCaptureComponent.prototype.ngOnDestroy = function () {
+            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();
+            }
+        };
+        return SelfieCaptureComponent;
+    }());
+    SelfieCaptureComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: SelfieCaptureComponent, deps: [{ token: i0__namespace.Renderer2 }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    SelfieCaptureComponent.ɵcmp = i0__namespace.ɵɵ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__namespace, 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__namespace.ChangeDetectionStrategy.OnPush });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: SelfieCaptureComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-selfie-capture",
+                        templateUrl: "./selfie.component.html",
+                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.Renderer2 }]; }, propDecorators: { strings: [{
+                    type: i0.Input
+                }], recorderOptions: [{
+                    type: i0.Input
+                }], hideCapturePrevBtn: [{
+                    type: i0.Input
+                }], hideCaptureBtn: [{
+                    type: i0.Input
+                }], selfie: [{
+                    type: i0.Output
+                }], recorderReady: [{
+                    type: i0.Output
+                }], recordStarting: [{
+                    type: i0.Output
+                }], recordCapturing: [{
+                    type: i0.Output
+                }], recordInterrupted: [{
+                    type: i0.Output
+                }], recordCompleted: [{
+                    type: i0.Output
+                }], selfieRef: [{
+                    type: i0.ViewChild,
+                    args: ["selfie"]
+                }] } });
+
+    var 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({}, webComponents.EN.videoRecordDirections),
+            recorder: Object.assign({}, webComponents.EN.videoRecorder),
+        } }, webComponents.EN);
+
+    var ImageCaptureDirectionsComponent = /** @class */ (function () {
+        function ImageCaptureDirectionsComponent() {
+            this.strings = EN.imageCaptureDirections;
+            this.instructions = "";
+        }
+        ImageCaptureDirectionsComponent.prototype.ngOnChanges = function (changes) {
+            if (changes.strings && !changes.strings.firstChange) {
+                this.instructions = JSON.stringify(changes.strings.currentValue);
+            }
+        };
+        ImageCaptureDirectionsComponent.prototype.ngOnInit = function () {
+            this.instructions = JSON.stringify(this.strings);
+        };
+        return ImageCaptureDirectionsComponent;
+    }());
+    ImageCaptureDirectionsComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: ImageCaptureDirectionsComponent, deps: [], target: i0__namespace.ɵɵFactoryTarget.Component });
+    ImageCaptureDirectionsComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: ImageCaptureDirectionsComponent, selector: "unissey-image-capture-directions", inputs: { strings: "strings" }, usesOnChanges: true, ngImport: i0__namespace, template: "<uni-image-capture-directions [attr.strings]=\"instructions\"></uni-image-capture-directions>\n" });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: ImageCaptureDirectionsComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-image-capture-directions",
+                        templateUrl: "./image-capture-directions.component.html",
+                    }]
+            }], propDecorators: { strings: [{
+                    type: i0.Input
+                }] } });
+
+    var PictureEditorComponent = /** @class */ (function () {
+        function PictureEditorComponent(renderer) {
+            this.renderer = renderer;
+            this.image = "";
+            this.strings = EN.pictureEditor;
+            this.validatedImage = new i0.EventEmitter();
+            this.editorStrings = "";
+        }
+        Object.defineProperty(PictureEditorComponent.prototype, "element", {
+            /**
+             * @internal
+             */
+            set: function (node) {
+                if (!node) {
+                    if (this.validationUnlistenFct) {
+                        this.validationUnlistenFct();
+                        this.validationUnlistenFct = undefined;
+                    }
+                    return;
+                }
+                this.validationUnlistenFct = this.renderer.listen(node.nativeElement, "picture", this.pictureValidated.bind(this));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        PictureEditorComponent.prototype.ngOnInit = function () {
+            this.editorStrings = JSON.stringify(this.strings);
+        };
+        PictureEditorComponent.prototype.ngOnChanges = function (changes) {
+            if (changes.strings && !changes.strings.firstChange) {
+                this.editorStrings = JSON.stringify(changes.strings.currentValue);
+            }
+        };
+        PictureEditorComponent.prototype.ngOnDestroy = function () {
+            if (this.validationUnlistenFct) {
+                this.validationUnlistenFct();
+            }
+        };
+        /**
+         * @internal
+         */
+        PictureEditorComponent.prototype.pictureValidated = function (event) {
+            var picture = event.detail.picture;
+            this.validatedImage.emit(picture);
+        };
+        return PictureEditorComponent;
+    }());
+    PictureEditorComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: PictureEditorComponent, deps: [{ token: i0__namespace.Renderer2 }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    PictureEditorComponent.ɵcmp = i0__namespace.ɵɵ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__namespace, 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__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: PictureEditorComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-picture-editor",
+                        templateUrl: "./picture-editor.component.html",
+                        styleUrls: ["./picture-editor.component.css"],
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.Renderer2 }]; }, propDecorators: { image: [{
+                    type: i0.Input
+                }], strings: [{
+                    type: i0.Input
+                }], validatedImage: [{
+                    type: i0.Output
+                }], element: [{
+                    type: i0.ViewChild,
+                    args: ["editor"]
+                }] } });
+
+    var PictureRecorderComponent = /** @class */ (function () {
+        function PictureRecorderComponent(renderer) {
+            this.renderer = renderer;
+            this.recorderOverlay = webComponents.OverlayDisplayMode.ID_DOCUMENT;
+            this.preset = webComponents.AcquisitionPreset.DOC_IMAGE;
+            this.config = {};
+            this.strings = EN.pictureRecorder;
+            this.displayFlipCameraBtn = undefined;
+            this.hideCaptureBtn = false;
+            this.faceChecker = "disabled";
+            this.logLevel = webComponents.LogLevel.QUIET;
+            this.picture = new i0.EventEmitter();
+            this.recordStarting = new i0.EventEmitter();
+            this.recordCapturing = new i0.EventEmitter();
+            this.recordInterrupted = new i0.EventEmitter();
+            this.recordCompleted = new i0.EventEmitter();
+            this.recorderStrings = "";
+        }
+        Object.defineProperty(PictureRecorderComponent.prototype, "recorder", {
+            set: function (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));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        PictureRecorderComponent.prototype.ngOnInit = function () {
+            this.recorderStrings = JSON.stringify(this.strings);
+        };
+        PictureRecorderComponent.prototype.ngOnChanges = function (changes) {
+            if (changes.strings && !changes.strings.firstChange) {
+                this.recorderStrings = JSON.stringify(changes.strings.currentValue);
+            }
+        };
+        PictureRecorderComponent.prototype.ngOnDestroy = function () {
+            if (this.pictureRecUnlistenFct) {
+                this.pictureRecUnlistenFct();
+            }
+        };
+        PictureRecorderComponent.prototype.pictureRecorded = function (event) {
+            var picture = event.detail.picture;
+            if (picture) {
+                this.picture.emit(picture);
+            }
+        };
+        /**
+         * @internal
+         */
+        PictureRecorderComponent.prototype.onRecordStarting = function (event) {
+            this.recordStarting.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        PictureRecorderComponent.prototype.onRecordCapturing = function (event) {
+            this.recordCapturing.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        PictureRecorderComponent.prototype.onRecordInterrupted = function (event) {
+            this.recordInterrupted.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        PictureRecorderComponent.prototype.onRecordCompleted = function (event) {
+            if (event.detail.picture) {
+                this.recordCompleted.emit(event.detail.picture);
+            }
+        };
+        return PictureRecorderComponent;
+    }());
+    PictureRecorderComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: PictureRecorderComponent, deps: [{ token: i0__namespace.Renderer2 }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    PictureRecorderComponent.ɵcmp = i0__namespace.ɵɵ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__namespace, 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__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: PictureRecorderComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-picture-recorder",
+                        templateUrl: "./picture-recorder.component.html",
+                        styleUrls: ["./picture-recorder.component.css"],
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.Renderer2 }]; }, propDecorators: { recorder: [{
+                    type: i0.ViewChild,
+                    args: ["recorder"]
+                }], preset: [{
+                    type: i0.Input
+                }], config: [{
+                    type: i0.Input
+                }], strings: [{
+                    type: i0.Input
+                }], displayFlipCameraBtn: [{
+                    type: i0.Input
+                }], hideCaptureBtn: [{
+                    type: i0.Input
+                }], faceChecker: [{
+                    type: i0.Input
+                }], logLevel: [{
+                    type: i0.Input
+                }], picture: [{
+                    type: i0.Output
+                }], recordStarting: [{
+                    type: i0.Output
+                }], recordCapturing: [{
+                    type: i0.Output
+                }], recordInterrupted: [{
+                    type: i0.Output
+                }], recordCompleted: [{
+                    type: i0.Output
+                }] } });
+
+    var FileUploadComponent = /** @class */ (function () {
+        function FileUploadComponent(renderer) {
+            this.renderer = renderer;
+            this.maxSize = 5000000;
+            this.supportedTypes = ["image/png", "image/jpeg", "image/jpg", "image/jp2"];
+            this.strings = EN.fileUpload;
+            this.file = new i0.EventEmitter();
+            this.stringifiedStrings = "";
+        }
+        /**
+         * @internal
+         */
+        FileUploadComponent.prototype.ngAfterViewInit = function () {
+            this.uploaderUnlistenCb = this.renderer.listen(this.uploader.nativeElement, "change", this.emitUploadedFile.bind(this));
+        };
+        FileUploadComponent.prototype.ngOnInit = function () {
+            this.stringifiedStrings = JSON.stringify(this.strings);
+        };
+        FileUploadComponent.prototype.ngOnChanges = function (changes) {
+            if (changes.strings && !changes.strings.firstChange) {
+                this.stringifiedStrings = JSON.stringify(changes.strings.currentValue);
+            }
+        };
+        /**
+         * @internal
+         */
+        FileUploadComponent.prototype.ngOnDestroy = function () {
+            if (this.uploaderUnlistenCb) {
+                this.uploaderUnlistenCb();
+            }
+        };
+        /**
+         * @internal
+         */
+        FileUploadComponent.prototype.emitUploadedFile = function (event) {
+            this.file.emit(event.detail.file);
+        };
+        return FileUploadComponent;
+    }());
+    FileUploadComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: FileUploadComponent, deps: [{ token: i0__namespace.Renderer2 }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    FileUploadComponent.ɵcmp = i0__namespace.ɵɵ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__namespace, 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__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: FileUploadComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-file-upload",
+                        templateUrl: "./file-upload.component.html",
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.Renderer2 }]; }, propDecorators: { uploader: [{
+                    type: i0.ViewChild,
+                    args: ["uploader"]
+                }], maxSize: [{
+                    type: i0.Input
+                }], supportedTypes: [{
+                    type: i0.Input
+                }], strings: [{
+                    type: i0.Input
+                }], file: [{
+                    type: i0.Output
+                }] } });
+
+    var RetryResultComponent = /** @class */ (function () {
+        function RetryResultComponent(renderer) {
+            this.renderer = renderer;
+            this.hint = "generic";
+            this.retriesLeft = 2;
+            this.strings = webComponents.EN.retryResult;
+            this.finish = new i0.EventEmitter();
+            this.retry = new i0.EventEmitter();
+            this.retryStringifiedStrings = "";
+        }
+        Object.defineProperty(RetryResultComponent.prototype, "retryView", {
+            set: function (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));
+            },
+            enumerable: false,
+            configurable: true
+        });
+        RetryResultComponent.prototype.ngOnInit = function () {
+            this.retryStringifiedStrings = JSON.stringify(this.retryStringifiedStrings);
+        };
+        RetryResultComponent.prototype.ngAfterViewInit = function () {
+            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);
+            }
+        };
+        RetryResultComponent.prototype.onFinishEvent = function (_) {
+            this.finish.emit();
+        };
+        RetryResultComponent.prototype.onRetryEvent = function (_) {
+            this.retry.emit();
+        };
+        return RetryResultComponent;
+    }());
+    RetryResultComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: RetryResultComponent, deps: [{ token: i0__namespace.Renderer2 }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    RetryResultComponent.ɵcmp = i0__namespace.ɵɵ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__namespace, 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__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: RetryResultComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-retry-result",
+                        templateUrl: "./retry-result.component.html",
+                        styleUrls: ["./retry-result.component.css"],
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.Renderer2 }]; }, propDecorators: { hint: [{
+                    type: i0.Input
+                }], retriesLeft: [{
+                    type: i0.Input
+                }], strings: [{
+                    type: i0.Input
+                }], finish: [{
+                    type: i0.Output
+                }], retry: [{
+                    type: i0.Output
+                }], retryView: [{
+                    type: i0.ViewChild,
+                    args: ["retryView"]
+                }] } });
+
+    var VideoCaptureDirectionsComponent = /** @class */ (function () {
+        function VideoCaptureDirectionsComponent() {
+            this.strings = EN.videoRecordDirections;
+            this.instructions = "";
+        }
+        VideoCaptureDirectionsComponent.prototype.ngOnChanges = function (changes) {
+            if (changes.strings && !changes.strings.firstChange) {
+                this.instructions = JSON.stringify(changes.strings.currentValue);
+            }
+        };
+        VideoCaptureDirectionsComponent.prototype.ngOnInit = function () {
+            this.instructions = JSON.stringify(this.strings);
+        };
+        return VideoCaptureDirectionsComponent;
+    }());
+    VideoCaptureDirectionsComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: VideoCaptureDirectionsComponent, deps: [], target: i0__namespace.ɵɵFactoryTarget.Component });
+    VideoCaptureDirectionsComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: VideoCaptureDirectionsComponent, selector: "unissey-video-capture-directions", inputs: { strings: "strings" }, usesOnChanges: true, ngImport: i0__namespace, template: "<uni-video-record-directions [attr.strings]=\"instructions\"></uni-video-record-directions>\n", styles: [""] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: VideoCaptureDirectionsComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-video-capture-directions",
+                        templateUrl: "./video-capture-directions.component.html",
+                        styleUrls: ["./video-capture-directions.component.css"],
+                    }]
+            }], propDecorators: { strings: [{
+                    type: i0.Input
+                }] } });
+
+    var VideoRecorderComponent = /** @class */ (function () {
+        function VideoRecorderComponent(renderer) {
+            this.renderer = renderer;
+            this.strings = EN.videoRecorder;
+            this.preset = webComponents.AcquisitionPreset.SELFIE_FAST;
+            this.config = {};
+            this.instructionMessages = [];
+            this.faceChecker = "disabled-on-retry";
+            this.displayFlipCameraBtn = false;
+            this.hideCaptureBtn = false;
+            this.logLevel = webComponents.LogLevel.QUIET;
+            this.record = new i0.EventEmitter();
+            this.recorderReady = new i0.EventEmitter();
+            this.recordStarting = new i0.EventEmitter();
+            this.recordCapturing = new i0.EventEmitter();
+            this.recordInterrupted = new i0.EventEmitter();
+            this.recordCompleted = new i0.EventEmitter();
+            this.issue = new i0.EventEmitter();
+        }
+        /**
+         * @internal
+         */
+        VideoRecorderComponent.prototype.ngOnInit = function () {
+            this.stringifiedStrings = JSON.stringify(this.strings);
+            this.stringifiedInstructionMessages = JSON.stringify(this.instructionMessages);
+            this.stringifiedConfig = JSON.stringify(this.config);
+        };
+        VideoRecorderComponent.prototype.ngOnChanges = function (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
+         */
+        VideoRecorderComponent.prototype.onRecord = function (event) {
+            this.record.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        VideoRecorderComponent.prototype.onRecorderReady = function (event) {
+            this.recorderReady.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        VideoRecorderComponent.prototype.onRecordStarting = function (event) {
+            this.recordStarting.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        VideoRecorderComponent.prototype.onRecordCapturing = function (event) {
+            this.recordCapturing.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        VideoRecorderComponent.prototype.onRecordInterrupted = function (event) {
+            this.recordInterrupted.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        VideoRecorderComponent.prototype.onRecordCompleted = function (event) {
+            this.recordCompleted.emit(event.detail);
+        };
+        /**
+         * @internal
+         */
+        VideoRecorderComponent.prototype.onRecordIssue = function (event) {
+            this.issue.emit(event.detail.issueType);
+        };
+        /**
+         * @internal
+         */
+        VideoRecorderComponent.prototype.ngAfterViewInit = function () {
+            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
+         */
+        VideoRecorderComponent.prototype.ngOnDestroy = function () {
+            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();
+            }
+        };
+        return VideoRecorderComponent;
+    }());
+    VideoRecorderComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: VideoRecorderComponent, deps: [{ token: i0__namespace.Renderer2 }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    VideoRecorderComponent.ɵcmp = i0__namespace.ɵɵ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__namespace, 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__namespace.ChangeDetectionStrategy.OnPush });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: VideoRecorderComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: "unissey-video-recorder",
+                        templateUrl: "./video-recorder.component.html",
+                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.Renderer2 }]; }, propDecorators: { strings: [{
+                    type: i0.Input
+                }], preset: [{
+                    type: i0.Input
+                }], config: [{
+                    type: i0.Input
+                }], instructionMessages: [{
+                    type: i0.Input
+                }], faceChecker: [{
+                    type: i0.Input
+                }], displayFlipCameraBtn: [{
+                    type: i0.Input
+                }], hideCaptureBtn: [{
+                    type: i0.Input
+                }], logLevel: [{
+                    type: i0.Input
+                }], record: [{
+                    type: i0.Output
+                }], recorderReady: [{
+                    type: i0.Output
+                }], recordStarting: [{
+                    type: i0.Output
+                }], recordCapturing: [{
+                    type: i0.Output
+                }], recordInterrupted: [{
+                    type: i0.Output
+                }], recordCompleted: [{
+                    type: i0.Output
+                }], issue: [{
+                    type: i0.Output
+                }], recorderRef: [{
+                    type: i0.ViewChild,
+                    args: ["camera"]
+                }] } });
+
+    var UnisseySdkModule = /** @class */ (function () {
+        function UnisseySdkModule() {
+        }
+        return UnisseySdkModule;
+    }());
+    UnisseySdkModule.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkModule, deps: [], target: i0__namespace.ɵɵFactoryTarget.NgModule });
+    UnisseySdkModule.ɵmod = i0__namespace.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkModule, declarations: [ButtonComponent,
+            FileUploadComponent,
+            FullCaptureComponent,
+            SelfieCaptureComponent,
+            ImageCaptureDirectionsComponent,
+            PictureEditorComponent,
+            PictureRecorderComponent,
+            ReferenceCaptureComponent,
+            RetryResultComponent,
+            VideoCaptureDirectionsComponent,
+            VideoRecorderComponent,
+            UnisseySdkComponent], imports: [common.CommonModule], exports: [ButtonComponent,
+            FileUploadComponent,
+            FullCaptureComponent,
+            SelfieCaptureComponent,
+            ImageCaptureDirectionsComponent,
+            PictureEditorComponent,
+            PictureRecorderComponent,
+            ReferenceCaptureComponent,
+            RetryResultComponent,
+            VideoCaptureDirectionsComponent,
+            VideoRecorderComponent,
+            UnisseySdkComponent] });
+    UnisseySdkModule.ɵinj = i0__namespace.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkModule, imports: [[common.CommonModule]] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: UnisseySdkModule, decorators: [{
+                type: i0.NgModule,
+                args: [{
+                        declarations: [
+                            ButtonComponent,
+                            FileUploadComponent,
+                            FullCaptureComponent,
+                            SelfieCaptureComponent,
+                            ImageCaptureDirectionsComponent,
+                            PictureEditorComponent,
+                            PictureRecorderComponent,
+                            ReferenceCaptureComponent,
+                            RetryResultComponent,
+                            VideoCaptureDirectionsComponent,
+                            VideoRecorderComponent,
+                            UnisseySdkComponent,
+                        ],
+                        imports: [common.CommonModule],
+                        exports: [
+                            ButtonComponent,
+                            FileUploadComponent,
+                            FullCaptureComponent,
+                            SelfieCaptureComponent,
+                            ImageCaptureDirectionsComponent,
+                            PictureEditorComponent,
+                            PictureRecorderComponent,
+                            ReferenceCaptureComponent,
+                            RetryResultComponent,
+                            VideoCaptureDirectionsComponent,
+                            VideoRecorderComponent,
+                            UnisseySdkComponent,
+                        ],
+                        schemas: [i0.CUSTOM_ELEMENTS_SCHEMA],
+                    }]
+            }] });
+
+    /*
+     * Public API Surface of @unissey-web/sdk-angular
+     */
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    Object.defineProperty(exports, 'AcquisitionPreset', {
+        enumerable: true,
+        get: function () { return webComponents.AcquisitionPreset; }
+    });
+    Object.defineProperty(exports, 'EN', {
+        enumerable: true,
+        get: function () { return webComponents.EN; }
+    });
+    Object.defineProperty(exports, 'FR', {
+        enumerable: true,
+        get: function () { return webComponents.FR; }
+    });
+    Object.defineProperty(exports, 'FacingMode', {
+        enumerable: true,
+        get: function () { return webComponents.FacingMode; }
+    });
+    Object.defineProperty(exports, 'IadMode', {
+        enumerable: true,
+        get: function () { return webComponents.IadMode; }
+    });
+    Object.defineProperty(exports, 'OverlayDisplayMode', {
+        enumerable: true,
+        get: function () { return webComponents.OverlayDisplayMode; }
+    });
+    Object.defineProperty(exports, 'VideoOrientation', {
+        enumerable: true,
+        get: function () { return webComponents.VideoOrientation; }
+    });
+    Object.defineProperty(exports, 'VideoResolutionPreset', {
+        enumerable: true,
+        get: function () { return webComponents.VideoResolutionPreset; }
+    });
+    exports.ButtonComponent = ButtonComponent;
+    exports.FileUploadComponent = FileUploadComponent;
+    exports.FullCaptureComponent = FullCaptureComponent;
+    exports.ImageCaptureDirectionsComponent = ImageCaptureDirectionsComponent;
+    exports.PictureEditorComponent = PictureEditorComponent;
+    exports.PictureRecorderComponent = PictureRecorderComponent;
+    exports.ReferenceCaptureComponent = ReferenceCaptureComponent;
+    exports.RetryResultComponent = RetryResultComponent;
+    exports.SelfieCaptureComponent = SelfieCaptureComponent;
+    exports.UnisseySdkComponent = UnisseySdkComponent;
+    exports.UnisseySdkModule = UnisseySdkModule;
+    exports.UnisseySdkService = UnisseySdkService;
+    exports.VideoCaptureDirectionsComponent = VideoCaptureDirectionsComponent;
+    exports.VideoRecorderComponent = VideoRecorderComponent;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=unissey-web-sdk-angular.umd.js.map