cordova-digital-onboarding 1.0.0 → 1.0.1

package/lib/index.js

@@ -0,0 +1,2001 @@
+'use strict';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Log levels for Wultra Digital Onboarding. */
+exports.WDOLogLevel = void 0;
+(function (WDOLogLevel) {
+    WDOLogLevel[WDOLogLevel["NONE"] = 0] = "NONE";
+    WDOLogLevel[WDOLogLevel["ERROR"] = 1] = "ERROR";
+    WDOLogLevel[WDOLogLevel["WARN"] = 2] = "WARN";
+    WDOLogLevel[WDOLogLevel["INFO"] = 3] = "INFO";
+    WDOLogLevel[WDOLogLevel["DEBUG"] = 4] = "DEBUG";
+})(exports.WDOLogLevel || (exports.WDOLogLevel = {}));
+/** Simple logger utility for Wultra Digital Onboarding SDK. */
+var WDOLogger = /** @class */ (function () {
+    function WDOLogger() {
+    }
+    /* @internal */
+    WDOLogger.debug = function (message) {
+        this.log(exports.WDOLogLevel.DEBUG, message);
+    };
+    /* @internal */
+    WDOLogger.info = function (message) {
+        this.log(exports.WDOLogLevel.INFO, message);
+    };
+    /* @internal */
+    WDOLogger.warn = function (message) {
+        this.log(exports.WDOLogLevel.WARN, message);
+    };
+    /* @internal */
+    WDOLogger.error = function (message) {
+        this.log(exports.WDOLogLevel.ERROR, message);
+    };
+    /* @internal */
+    WDOLogger.log = function (level, message) {
+        if (level <= this.logLevel) {
+            console.log("[WDO][".concat(exports.WDOLogLevel[level], "] ").concat(message));
+        }
+        if (this.listener) {
+            this.listener.log(level, message);
+        }
+    };
+    /** Current log level. Messages with a level higher than this will not be logged. */
+    WDOLogger.logLevel = exports.WDOLogLevel.INFO;
+    /** Listener for custom logging implementation */
+    WDOLogger.listener = null;
+    return WDOLogger;
+}());
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// TODO: add ERROR codes
+var WDOError = /** @class */ (function () {
+    function WDOError(message, additionalInfo) {
+        this.message = message;
+        this.additionalInfo = additionalInfo;
+    }
+    return WDOError;
+}());
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Service that can activate PowerAuth instance by user weak credentials (like his email, phone number or client ID) + optional SMS OTP.
+ *
+ * When the PowerAuth is activated with this service, `WDOVerificationService.isVerificationRequired` will be `true`
+ * and you will need to verify the PowerAuth instance via `WDOVerificationService`.
+ *
+ * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
+ */
+var WDOBaseActivationService = /** @class */ (function () {
+    function WDOBaseActivationService() {
+    }
+    Object.defineProperty(WDOBaseActivationService.prototype, "hasActiveProcess", {
+        /**
+         * If the activation process is in progress.
+         *
+         * Note that even if this property is `true` it can be already discontinued on the server.
+         * Calling `status()` for example after the app is launched in this case is recommended.
+         */
+        get: function () { return !!this.processData; },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Accept language for the outgoing requests headers.
+     * Default value is "en".
+     *
+     * Standard RFC "Accept-Language" https://tools.ietf.org/html/rfc7231#section-5.3.5
+     * Response texts are based on this setting. For example when "de" is set, server
+     * will return error texts and other in german (if available).
+     */
+    WDOBaseActivationService.prototype.changeAcceptLanguage = function (language) {
+        this.changeAcceptLanguageImpl(language);
+    };
+    Object.defineProperty(WDOBaseActivationService.prototype, "processId", {
+        /* @internal  */
+        get: function () { var _a; return (_a = this.processData) === null || _a === void 0 ? void 0 : _a.processId; },
+        enumerable: false,
+        configurable: true
+    });
+    // PUBLIC API
+    /**
+     * Retrieves status of the onboarding activation.
+     *
+     * @return Promise resolved with onboarding status.
+     */
+    WDOBaseActivationService.prototype.status = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Getting activation status for processId=".concat(this.processId));
+                        return [4 /*yield*/, this.verifyCanStartProcess()];
+                    case 1:
+                        _a.sent();
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.api.activationGetStatus(pid)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, result.onboardingStatus];
+                }
+            });
+        });
+    };
+    /**
+     * Start onboarding activation with user credentials.
+     *
+     * For example, when you require email and birth date, your object would look like this:
+     * ```
+     * {
+     *   email: "<user_email>",
+     *   birthdate: "<user_birth_date>"
+     * }
+     * ```
+     * @param credentials Object with credentials. Which credentials are needed should be provided by a system/backend provider.
+     * @param processType The process type identification. If not specified, the default process type will be used.
+     */
+    WDOBaseActivationService.prototype.start = function (credentials, processType) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Starting activation with credentials: ".concat(JSON.stringify(credentials)));
+                        if (this.processId) {
+                            throw new WDOError("Cannot start the process - processId already obtained, cancel first.");
+                        }
+                        return [4 /*yield*/, this.verifyCanStartProcess()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.api.activationStart(credentials, processType)];
+                    case 2:
+                        result = _a.sent();
+                        WDOLogger.info("WDOActivationService.start success");
+                        WDOLogger.debug(" - processId: ".concat(result.processId));
+                        this.processData = { processId: result.processId, activationCode: result.activationCode };
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Cancel the activation process (issues a cancel request to the backend and clears the local process ID).
+     *
+     * @param forceCancel When true, the process will be canceled in the SDK even when fails on backend. `true` by default.
+     */
+    WDOBaseActivationService.prototype.cancel = function () {
+        return __awaiter(this, arguments, void 0, function (forceCancel) {
+            var pid, error_1;
+            if (forceCancel === void 0) { forceCancel = true; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Canceling activation for processId=".concat(this.processId, ", forceCancel=").concat(forceCancel));
+                        pid = this.verifyHasActiveProcess();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.api.activationCancel(pid)];
+                    case 2:
+                        _a.sent();
+                        this.processData = undefined;
+                        WDOLogger.info("WDOActivationService.cancel success");
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        if (forceCancel) {
+                            // pretend it was successful and just log the error
+                            WDOLogger.debug("Process canceled (but the request failed) - ".concat(error_1, "."));
+                            this.processData = undefined;
+                        }
+                        else {
+                            throw error_1; // rethrow
+                        }
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Clear the stored data (without networking call). */
+    WDOBaseActivationService.prototype.clear = function () {
+        this.processData = undefined;
+    };
+    /**
+     * OTP resend request.
+     *
+     * This is intended to be displayed for the user to use in case of the OTP is not received.
+     * For example, when the user does not receive SMS after some time, there should be a button to "send again".
+     */
+    WDOBaseActivationService.prototype.resendOTP = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Activation: resending OTP");
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.verifyCanStartProcess()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.api.activationResendOTP(pid)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * @internal
+     * Demo endpoint available only in Wultra Demo systems.
+     *
+     * If the app is running against our demo server, you can retrieve the OTP without needing to send SMS or emails.
+     */
+    WDOBaseActivationService.prototype.getOTP = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Activation: getting OTP from server (only for testing purposes)");
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.api.activationGetOTP(pid, "ACTIVATION")];
+                    case 1: return [2 /*return*/, (_a.sent()).otpCode];
+                }
+            });
+        });
+    };
+    /**
+     * Activate the PowerAuth instance that was passed in the initializer.
+     *
+     * @param activationName Name of the activation. Device name by default (usually something like John's iPhone or similar).
+     * @param otp OTP code received by the user (via SMS or email). Optional when not required.
+     * @return Promise resolved with activation result.
+     */
+    WDOBaseActivationService.prototype.activate = function (activationName, otp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, code, result, identityAttributes;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        WDOLogger.debug("Activating the PowerAuth with activation name '".concat(activationName, "'"));
+                        return [4 /*yield*/, this.verifyCanStartProcess()];
+                    case 1:
+                        _b.sent();
+                        pid = this.verifyHasActiveProcess();
+                        code = (_a = this.processData) === null || _a === void 0 ? void 0 : _a.activationCode;
+                        if (!code) return [3 /*break*/, 3];
+                        WDOLogger.info("Activating PowerAuth using activation code from the onboarding process");
+                        return [4 /*yield*/, this.activatePowerAuthWithCode(code, otp, activationName)];
+                    case 2:
+                        result = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        WDOLogger.info("Activating PowerAuth using identity attributes from the onboarding process");
+                        identityAttributes = { processId: pid, otpCode: otp, credentialsType: "ONBOARDING" };
+                        return [4 /*yield*/, this.activatePowerAuth(identityAttributes, activationName)];
+                    case 4:
+                        result = _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        // Clear process ID after activation attempt
+                        this.processData = undefined;
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    // PRIVATE METHODS
+    /* @internal */
+    WDOBaseActivationService.prototype.verifyCanStartProcess = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.api.canStartActivation()];
+                    case 1:
+                        if (!(_a.sent())) {
+                            WDOLogger.error("PowerAuth is already activated - Activation cannot be started/processed.");
+                            this.processData = undefined;
+                            throw new WDOError("PowerAuth is already activated");
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* @internal */
+    WDOBaseActivationService.prototype.verifyHasActiveProcess = function () {
+        var pid = this.processId;
+        if (!pid) {
+            WDOLogger.warn("Cannot proceed (processId not available).");
+            throw new WDOError("No active activation process");
+        }
+        return pid;
+    };
+    return WDOBaseActivationService;
+}());
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var WDOActivationEndpoints = /** @class */ (function () {
+    function WDOActivationEndpoints() {
+    }
+    WDOActivationEndpoints.start = {
+        path: "/api/onboarding/start",
+        e2eeScope: "APPLICATION",
+        returnsData: true
+    };
+    WDOActivationEndpoints.cancel = {
+        path: "/api/onboarding/cleanup",
+        e2eeScope: "APPLICATION",
+        returnsData: false
+    };
+    WDOActivationEndpoints.resendOTP = {
+        path: "/api/onboarding/otp/resend",
+        e2eeScope: "APPLICATION",
+        returnsData: false
+    };
+    WDOActivationEndpoints.getStatus = {
+        path: "/api/onboarding/status",
+        e2eeScope: "APPLICATION",
+        returnsData: true
+    };
+    return WDOActivationEndpoints;
+}());
+var WDOVerificationEndpoints = /** @class */ (function () {
+    function WDOVerificationEndpoints() {
+    }
+    WDOVerificationEndpoints.getStatus = {
+        path: "/api/identity/status",
+        e2eeScope: "NONE",
+        tokenName: "possession_universal",
+        returnsData: true
+    };
+    WDOVerificationEndpoints.init = {
+        path: "/api/identity/init",
+        uriId: "/api/identity/init",
+        e2eeScope: "NONE",
+        returnsData: false
+    };
+    WDOVerificationEndpoints.cancel = {
+        path: "/api/identity/cleanup",
+        uriId: "/api/identity/cleanup",
+        e2eeScope: "NONE",
+        returnsData: false
+    };
+    WDOVerificationEndpoints.consentText = {
+        path: "/api/identity/consent/text",
+        tokenName: "possession_universal",
+        e2eeScope: "NONE",
+        returnsData: true
+    };
+    WDOVerificationEndpoints.consentApprove = {
+        path: "/api/identity/consent/approve",
+        uriId: "/api/identity/consent/approve",
+        e2eeScope: "NONE",
+        returnsData: false
+    };
+    WDOVerificationEndpoints.documentScanSdkInit = {
+        path: "/api/identity/document/init-sdk",
+        uriId: "/api/identity/document/init-sdk",
+        e2eeScope: "ACTIVATION",
+        returnsData: true
+    };
+    // Legacy endpoint that required zip file upload
+    WDOVerificationEndpoints.submitDocuments = {
+        path: "/api/identity/document/submit",
+        tokenName: "possession_universal",
+        e2eeScope: "ACTIVATION",
+        returnsData: false
+    };
+    WDOVerificationEndpoints.v2submitDocuments = {
+        path: "/api/v2/identity/document/submit",
+        tokenName: "possession_universal",
+        e2eeScope: "ACTIVATION",
+        returnsData: false
+    };
+    WDOVerificationEndpoints.documentsStatus = {
+        path: "/api/identity/document/status",
+        tokenName: "possession_universal",
+        e2eeScope: "NONE",
+        returnsData: true
+    };
+    WDOVerificationEndpoints.presenceCheckInit = {
+        path: "/api/identity/presence-check/init",
+        uriId: "/api/identity/presence-check/init",
+        e2eeScope: "ACTIVATION",
+        returnsData: true
+    };
+    WDOVerificationEndpoints.presenceCheckSubmit = {
+        path: "/api/identity/presence-check/submit",
+        uriId: "/api/identity/presence-check/submit",
+        e2eeScope: "NONE",
+        returnsData: false
+    };
+    WDOVerificationEndpoints.resendOTP = {
+        path: "/api/identity/otp/resend",
+        uriId: "/api/identity/otp/resend",
+        e2eeScope: "NONE",
+        returnsData: false
+    };
+    WDOVerificationEndpoints.verifyOTP = {
+        path: "/api/identity/otp/verify",
+        e2eeScope: "ACTIVATION",
+        returnsData: true
+    };
+    return WDOVerificationEndpoints;
+}());
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var WDOBaseApi = /** @class */ (function () {
+    function WDOBaseApi() {
+    }
+    // Configuration endpoints
+    WDOBaseApi.prototype.getConfiguration = function (processType) {
+        var requestObject = { processType: processType };
+        return this.callApi(requestObject, { path: "/api/configuration", e2eeScope: "APPLICATION", returnsData: true });
+    };
+    // Activation endpoints
+    WDOBaseApi.prototype.activationStart = function (credentials, processType) {
+        var requestObject = { identification: credentials, processType: processType };
+        return this.callApi(requestObject, WDOActivationEndpoints.start);
+    };
+    WDOBaseApi.prototype.activationCancel = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOActivationEndpoints.cancel);
+    };
+    WDOBaseApi.prototype.activationGetStatus = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOActivationEndpoints.getStatus);
+    };
+    WDOBaseApi.prototype.activationResendOTP = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOActivationEndpoints.resendOTP);
+    };
+    WDOBaseApi.prototype.activationGetOTP = function (processId, otpType) {
+        var requestObject = { processId: processId, otpType: otpType };
+        return this.callApi(requestObject, { path: "/api/onboarding/otp/detail", e2eeScope: "APPLICATION", returnsData: true });
+    };
+    // Verification endpoints
+    WDOBaseApi.prototype.verificationStatus = function () {
+        var requestObject = {};
+        return this.callApi(requestObject, WDOVerificationEndpoints.getStatus);
+    };
+    WDOBaseApi.prototype.verificationStart = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOVerificationEndpoints.init);
+    };
+    WDOBaseApi.prototype.verificationCleanup = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOVerificationEndpoints.cancel);
+    };
+    WDOBaseApi.prototype.verificationGetConsentText = function (processId) {
+        var requestObject = { processId: processId, consentType: "GDPR" }; // TODO: hardcoded type
+        return this.callApi(requestObject, WDOVerificationEndpoints.consentText);
+    };
+    WDOBaseApi.prototype.verificationResolveConsent = function (processId, approved) {
+        var requestObject = { processId: processId, approved: approved, consentType: "GDPR" }; // TODO: hardcoded type
+        return this.callApi(requestObject, WDOVerificationEndpoints.consentApprove);
+    };
+    WDOBaseApi.prototype.verificationInitScanSDK = function (processId, challenge) {
+        var requestObject = { processId: processId, attributes: { 'sdk-init-token': challenge } };
+        return this.callApi(requestObject, WDOVerificationEndpoints.documentScanSdkInit);
+    };
+    WDOBaseApi.prototype.verificationSubmitDocumentsV2 = function (processId, resubmit, documents) {
+        var requestObject = {
+            processId: processId,
+            resubmit: resubmit,
+            documents: documents
+        };
+        // TODO: there should be longer timeout!
+        return this.callApi(requestObject, WDOVerificationEndpoints.v2submitDocuments);
+    };
+    WDOBaseApi.prototype.verificationSubmitDocuments = function (processId, data, resubmit, documents) {
+        var requestObject = { processId: processId, data: data, resubmit: resubmit, documents: documents };
+        // TODO: there should be longer timeout!
+        return this.callApi(requestObject, WDOVerificationEndpoints.submitDocuments);
+    };
+    WDOBaseApi.prototype.verificationDocumentsStatus = function (processId) {
+        var requestObject = { processId: processId };
+        // TODO: longer timeout?
+        return this.callApi(requestObject, WDOVerificationEndpoints.documentsStatus);
+    };
+    WDOBaseApi.prototype.verificationPresenceCheckInit = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOVerificationEndpoints.presenceCheckInit);
+    };
+    WDOBaseApi.prototype.verificationPresenceCheckSubmit = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOVerificationEndpoints.presenceCheckSubmit);
+    };
+    WDOBaseApi.prototype.verificationResendOTP = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOVerificationEndpoints.resendOTP);
+    };
+    WDOBaseApi.prototype.verifyOTP = function (processId, otp) {
+        var requestObject = { processId: processId, otpCode: otp };
+        return this.callApi(requestObject, WDOVerificationEndpoints.verifyOTP);
+    };
+    return WDOBaseApi;
+}());
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+var WDOApi = /** @class */ (function (_super) {
+    __extends(WDOApi, _super);
+    function WDOApi(powerauth, baseUrl) {
+        var _this = _super.call(this) || this;
+        // TODO: additional configuration?
+        _this.networking = new WPNNetworking(powerauth, baseUrl);
+        _this.powerauth = powerauth;
+        return _this;
+    }
+    WDOApi.prototype.callApi = function (requestObject, endpoint) {
+        return this.networking.call(
+        // construct 
+        this.constructEndpoint(endpoint), { requestObject: requestObject }, endpoint.tokenName || endpoint.uriId ? PowerAuthAuthentication.possession() : undefined // if signed, use possession auth
+        ).then(function (result) {
+            if (result.responseObject) {
+                return result.responseObject;
+            }
+            else if (result.responseError) {
+                throw new WDOError("Server API error: ".concat(result.responseError.code, ", ").concat(result.responseError.message), result.responseError);
+            }
+            else if (!endpoint.returnsData) {
+                // for void responses
+                return {};
+            }
+            else {
+                throw new WDOError("Failed to retrieve activation data");
+            }
+        });
+    };
+    WDOApi.prototype.canStartActivation = function () {
+        return this.powerauth.canStartActivation();
+    };
+    WDOApi.prototype.constructEndpoint = function (endpoint) {
+        var scope;
+        if (endpoint.e2eeScope === "ACTIVATION") {
+            scope = WPNE2EEConfiguration.ACTIVATION_SCOPE;
+        }
+        else if (endpoint.e2eeScope === "APPLICATION") {
+            scope = WPNE2EEConfiguration.APPLICATION_SCOPE;
+        }
+        else {
+            scope = WPNE2EEConfiguration.NOT_ENCRYPTED;
+        }
+        if (endpoint.uriId) {
+            return WPNEndpoint.signed(endpoint.path, endpoint.uriId, undefined, scope);
+        }
+        else if (endpoint.tokenName) {
+            return WPNEndpoint.signedWithToken(endpoint.path, endpoint.tokenName, undefined, scope);
+        }
+        else {
+            return WPNEndpoint.unsigned(endpoint.path, undefined, scope);
+        }
+    };
+    return WDOApi;
+}(WDOBaseApi));
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Service that can activate PowerAuth instance by user weak credentials (like his email, phone number or client ID) + optional SMS OTP.
+ *
+ * When the PowerAuth is activated with this service, `WDOVerificationService.isVerificationRequired` will be `true`
+ * and you will need to verify the PowerAuth instance via `WDOVerificationService`.
+ *
+ * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
+ */
+var WDOActivationService = /** @class */ (function (_super) {
+    __extends(WDOActivationService, _super);
+    /**
+     * Creates service instance
+     *
+     * @param powerauth Configured PowerAuth instance. This instance needs to be without valid activation.
+     * @param baseUrl Base URL of the Wultra Digital Onboarding server. Usually ending with `/enrollment-onboarding-server`.
+     */
+    function WDOActivationService(powerauth, baseUrl) {
+        var _this = _super.call(this) || this;
+        _this.api = new WDOApi(powerauth, baseUrl);
+        _this.powerauth = powerauth;
+        return _this;
+    }
+    /* @internal */
+    WDOActivationService.prototype.activatePowerAuth = function (identityAttributes, activationName) {
+        var activation = PowerAuthActivation.createWithIdentityAttributes(identityAttributes, activationName);
+        return this.powerauth.createActivation(activation);
+    };
+    /* @internal */
+    WDOActivationService.prototype.activatePowerAuthWithCode = function (activationCode, otp, activationName) {
+        var activation = PowerAuthActivation.createWithActivationCode(activationCode, activationName);
+        if (otp) {
+            activation.additionalActivationOtp = otp;
+        }
+        return this.powerauth.createActivation(activation);
+    };
+    /* @internal */
+    WDOActivationService.prototype.changeAcceptLanguageImpl = function (language) {
+        this.api.networking.acceptLanguage = language;
+    };
+    return WDOActivationService;
+}(WDOBaseActivationService));
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The `WDOPowerAuthActivationState` enum defines all possible states of activation.
+ * The state is a part of information received together with the rest
+ * of the `WDOPowerAuthActivationStatus` object.
+ */
+var WDOPowerAuthActivationState;
+(function (WDOPowerAuthActivationState) {
+    /**
+     * The activation is just created.
+     */
+    WDOPowerAuthActivationState["CREATED"] = "CREATED";
+    /**
+     * The activation is not completed yet on the server.
+     */
+    WDOPowerAuthActivationState["PENDING_COMMIT"] = "PENDING_COMMIT";
+    /**
+     * The shared secure context is valid and active.
+     */
+    WDOPowerAuthActivationState["ACTIVE"] = "ACTIVE";
+    /**
+     * The activation is blocked.
+     */
+    WDOPowerAuthActivationState["BLOCKED"] = "BLOCKED";
+    /**
+     * The activation doesn't exist anymore.
+     */
+    WDOPowerAuthActivationState["REMOVED"] = "REMOVED";
+    /**
+     * The activation is technically blocked. You cannot use it anymore
+     * for the signature calculations.
+     */
+    WDOPowerAuthActivationState["DEADLOCK"] = "DEADLOCK";
+})(WDOPowerAuthActivationState || (WDOPowerAuthActivationState = {}));
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Image of a document that can be sent to the backend for Identity Verification. */
+var WDODocumentFile = /** @class */ (function () {
+    /**
+     * Image of a document that can be sent to the backend for Identity Verification.
+     *
+     * @param data Raw image data. Make sure that the data aren't too big, hundreds of kbs should be enough.
+     * @param type Type of the document.
+     * @param side The side of the document that the image captures.
+     * @param originalDocumentId Original document ID In case of a reupload. If you've previously uploaded this type and side and won't specify the previous ID, the image won't be overwritten.
+     * @param dataSignature Signature of the image data. Optional, use only when the scan SDK supports this. `undefined` by default.
+     */
+    function WDODocumentFile(data, type, side, originalDocumentId, dataSignature) {
+        this.data = data;
+        this.dataSignature = dataSignature;
+        this.type = type;
+        this.side = side;
+        this.originalDocumentId = originalDocumentId;
+    }
+    /**
+     * Create the document file from an image that can be sent to the backend for Identity Verification.
+     *
+     * @param scannedDocument Document to upload.
+     * @param side The side of the document that the image captures.
+     * @param data Raw image data. Make sure that the data aren't too big, hundreds of kbs should be enough.
+     * @param dataSignature Signature of the image data. Optional, use only when the scan SDK supports this. `undefined` by default.
+     * @returns Document file to upload.
+     */
+    WDODocumentFile.fromScannedDocument = function (scannedDocument, side, data, dataSignature) {
+        var _a;
+        var originalDocumentId = (_a = scannedDocument.sides.find(function (s) { return s.type === side; })) === null || _a === void 0 ? void 0 : _a.serverId;
+        return new WDODocumentFile(data, scannedDocument.type, side, originalDocumentId, dataSignature);
+    };
+    return WDODocumentFile;
+}());
+/** Type of the document. */
+exports.WDODocumentType = void 0;
+(function (WDODocumentType) {
+    /** National ID card */
+    WDODocumentType["idCard"] = "idCard";
+    /** Passport */
+    WDODocumentType["passport"] = "passport";
+    /** Drivers license */
+    WDODocumentType["driversLicense"] = "driversLicense";
+})(exports.WDODocumentType || (exports.WDODocumentType = {}));
+/**
+ * Available sides of the document
+ *
+ * Front and back for ID card.
+ * For passport and drivers license front only.
+ */
+function WDODocumentTypeSides(type) {
+    switch (type) {
+        case exports.WDODocumentType.idCard:
+            return [exports.WDODocumentSide.front, exports.WDODocumentSide.back];
+        case exports.WDODocumentType.passport:
+            return [exports.WDODocumentSide.front];
+        case exports.WDODocumentType.driversLicense:
+            return [exports.WDODocumentSide.front];
+    }
+}
+/** Side of the document */
+exports.WDODocumentSide = void 0;
+(function (WDODocumentSide) {
+    /** Front side of a document. Usually the one with the picture.
+     *
+     * When a document has more than one side but only one side is used (for example passport), then such side is considered to be front.
+     */
+    WDODocumentSide["front"] = "front";
+    /** Back side of a document */
+    WDODocumentSide["back"] = "back";
+})(exports.WDODocumentSide || (exports.WDODocumentSide = {}));
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Status of the onboarding */
+var WDOOnboardingStatus;
+(function (WDOOnboardingStatus) {
+    /** Activation part of the process is in progress */
+    WDOOnboardingStatus["activationInProgress"] = "ACTIVATION_IN_PROGRESS";
+    /** Verification part of the process is in progress */
+    WDOOnboardingStatus["verificationInProgress"] = "VERIFICATION_IN_PROGRESS";
+    /** Onboarding process has failed */
+    WDOOnboardingStatus["failed"] = "FAILED";
+    /** Onboarding process is completed */
+    WDOOnboardingStatus["finished"] = "FINISHED";
+})(WDOOnboardingStatus || (WDOOnboardingStatus = {}));
+/** Status of the current identity verification */
+var WDOIdentityVerificationStatus;
+(function (WDOIdentityVerificationStatus) {
+    /** Identity verification is waiting for initialization */
+    WDOIdentityVerificationStatus["notInitialized"] = "NOT_INITIALIZED";
+    /** All submitted documents are waiting for verification */
+    WDOIdentityVerificationStatus["verificationPending"] = "VERIFICATION_PENDING";
+    /** Identity verification is in progress */
+    WDOIdentityVerificationStatus["inProgress"] = "IN_PROGRESS";
+    /** Identity verification was successfully completed */
+    WDOIdentityVerificationStatus["accepted"] = "ACCEPTED";
+    /** Identity verification has failed, an error occurred */
+    WDOIdentityVerificationStatus["failed"] = "FAILED";
+    /** Identity verification was rejected */
+    WDOIdentityVerificationStatus["rejected"] = "REJECTED";
+})(WDOIdentityVerificationStatus || (WDOIdentityVerificationStatus = {}));
+/** Phase of the current identity verification */
+var WDOIdentityVerificationPhase;
+(function (WDOIdentityVerificationPhase) {
+    /** Document upload is in progress */
+    WDOIdentityVerificationPhase["documentUpload"] = "DOCUMENT_UPLOAD";
+    /** Presence check is in progress */
+    WDOIdentityVerificationPhase["presenceCheck"] = "PRESENCE_CHECK";
+    /** Backend is verifying documents */
+    WDOIdentityVerificationPhase["clientEvaluation"] = "CLIENT_EVALUATION";
+    /** Document verification is in progress */
+    WDOIdentityVerificationPhase["documentVerification"] = "DOCUMENT_VERIFICATION";
+    /** Cross check on documents is in progress */
+    WDOIdentityVerificationPhase["documentVerificationFinal"] = "DOCUMENT_VERIFICATION_FINAL";
+    /** OTP verification needed */
+    WDOIdentityVerificationPhase["otp"] = "OTP_VERIFICATION";
+    /** Completed */
+    WDOIdentityVerificationPhase["completed"] = "COMPLETED";
+})(WDOIdentityVerificationPhase || (WDOIdentityVerificationPhase = {}));
+/** Types of available documents */
+var WDODocumentSubmitFileType;
+(function (WDODocumentSubmitFileType) {
+    /** National ID card */
+    WDODocumentSubmitFileType["idCard"] = "ID_CARD";
+    /** Passport */
+    WDODocumentSubmitFileType["passport"] = "PASSPORT";
+    /** Driving license */
+    WDODocumentSubmitFileType["driversLicense"] = "DRIVING_LICENSE";
+    /** Selfie photo */
+    WDODocumentSubmitFileType["selfiePhoto"] = "SELFIE_PHOTO";
+})(WDODocumentSubmitFileType || (WDODocumentSubmitFileType = {}));
+/** Side of the file */
+var WDODocumentSubmitFileSide;
+(function (WDODocumentSubmitFileSide) {
+    /** Front side of an document. Usually the one with the picture */
+    WDODocumentSubmitFileSide["front"] = "FRONT";
+    /** Back side of an document */
+    WDODocumentSubmitFileSide["back"] = "BACK";
+})(WDODocumentSubmitFileSide || (WDODocumentSubmitFileSide = {}));
+/** Status of the document */
+var WDODocumentStatus;
+(function (WDODocumentStatus) {
+    /** Document was accepted */
+    WDODocumentStatus["accepted"] = "ACCEPTED";
+    /** Document is being uploaded to the verification system by the backend */
+    WDODocumentStatus["uploadInProgress"] = "UPLOAD_IN_PROGRESS";
+    /** Document are being processed */
+    WDODocumentStatus["inProgress"] = "IN_PROGRESS";
+    /** Document is pending verification */
+    WDODocumentStatus["verificationPending"] = "VERIFICATION_PENDING";
+    /** Document is being verified */
+    WDODocumentStatus["verificationInProgress"] = "VERIFICATION_IN_PROGRESS";
+    /** Document was rejected */
+    WDODocumentStatus["rejected"] = "REJECTED";
+    /** Verification of the document failed */
+    WDODocumentStatus["failed"] = "FAILED";
+})(WDODocumentStatus || (WDODocumentStatus = {}));
+/** Converts WDODocumentType to DocumentSubmitFileType */
+function WDOCreateDocumentSubmitFileType(type) {
+    switch (type) {
+        case exports.WDODocumentType.idCard:
+            return WDODocumentSubmitFileType.idCard;
+        case exports.WDODocumentType.passport:
+            return WDODocumentSubmitFileType.passport;
+        case exports.WDODocumentType.driversLicense:
+            return WDODocumentSubmitFileType.driversLicense;
+    }
+}
+/** Converts WDODocumentSide to DocumentSubmitFileSide */
+function WDOCreateDocumentSubmitFileSide(side) {
+    switch (side) {
+        case exports.WDODocumentSide.front:
+            return WDODocumentSubmitFileSide.front;
+        case exports.WDODocumentSide.back:
+            return WDODocumentSubmitFileSide.back;
+    }
+}
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Types of the verification state */
+exports.WDOVerificationStateType = void 0;
+(function (WDOVerificationStateType) {
+    /**
+     * Show the verification introduction screen where the user can start the activation.
+     *
+     * The next step should be calling the `consentGet()`.
+     */
+    WDOVerificationStateType["intro"] = "intro";
+    /**
+     * Show approve/cancel user consent.
+     *
+     * The content of the text depends on the server configuration and might be plain text or HTML.
+     *
+     * The next step should be calling the `consentApprove`.
+     */
+    WDOVerificationStateType["consent"] = "consent";
+    /**
+     * Show document selection to the user. Which documents are available and how many
+     * can the user select is up to your backend configuration.
+     *
+     * The next step should be calling the `documentsSetSelectedTypes`.
+     */
+    WDOVerificationStateType["documentsToScanSelect"] = "documentsToScanSelect";
+    /**
+     * User should scan documents - display UI for the user to scan all necessary documents.
+     *
+     * The next step should be calling the `documentsSubmit`.
+     */
+    WDOVerificationStateType["scanDocument"] = "scanDocument";
+    /**
+     * The system is processing data - show loading with text hint from provided `WDOStatusCheckReason`.
+     *
+     * The next step should be calling the `status`.
+     */
+    WDOVerificationStateType["processing"] = "processing";
+    /**
+     * The user should be presented with a presence check.
+     * Presence check is handled by third-party SDK based on the project setup.
+     *
+     * The next step should be calling the `presenceCheckInit` to start the check and `presenceCheckSubmit` to
+     * mark it finished.  Note that these methods won't change the status and it's up to the app to handle the process of the presence check.
+     */
+    WDOVerificationStateType["presenceCheck"] = "presenceCheck";
+    /**
+     * Show enter OTP screen with resend button.
+     *
+     * The next step should be calling the `verifyOTP` with user-entered OTP.
+     * The OTP is usually SMS or email.
+     */
+    WDOVerificationStateType["otp"] = "otp";
+    /**
+     * Verification failed and can be restarted
+     *
+     * The next step should be calling the `restartVerification` or `cancelWholeProcess` based on
+     * the user's decision if he wants to try it again or cancel the process.
+     */
+    WDOVerificationStateType["failed"] = "failed";
+    /**
+     * Verification is canceled and the user needs to start again with a new PowerAuth activation.
+     *
+     * The next step should be calling the `PowerAuth.removeActivationLocal()` and starting activation from scratch.
+     */
+    WDOVerificationStateType["endState"] = "endState";
+    /**
+     * Verification was successfully ended. Continue into your app flow.
+     */
+    WDOVerificationStateType["success"] = "success";
+})(exports.WDOVerificationStateType || (exports.WDOVerificationStateType = {}));
+/** The reason why the process ended in a non-recoverable state. */
+exports.WDOEndStateReason = void 0;
+(function (WDOEndStateReason) {
+    /**
+     * The verification was rejected by the system
+     *
+     * eg: Fake information, fraud detection, or user is trying repeatedly in a short time.
+     * The real reason is not presented to the user and is only audited on the server.
+     */
+    WDOEndStateReason["rejected"] = "rejected";
+    /**
+     * The limit of repeat tries was reached. There is a fixed number of tries that the user can reach
+     * before the system stops the process.
+     */
+    WDOEndStateReason["limitReached"] = "limitReached";
+    /** An unknown reason. */
+    WDOEndStateReason["other"] = "other";
+})(exports.WDOEndStateReason || (exports.WDOEndStateReason = {}));
+/**
+ * The reason for what we are waiting for. For example, we can wait for documents to be OCRed and matched against the database.
+ * Use these values for better loading texts to tell the user what is happening - some tasks may take some time
+ * and it would be frustrating to just show a generic loading indicator.
+ */
+exports.WDOStatusCheckReason = void 0;
+(function (WDOStatusCheckReason) {
+    WDOStatusCheckReason["unknown"] = "unknown";
+    WDOStatusCheckReason["documentUpload"] = "documentUpload";
+    WDOStatusCheckReason["documentVerification"] = "documentVerification";
+    WDOStatusCheckReason["documentAccepted"] = "documentAccepted";
+    WDOStatusCheckReason["documentsCrossVerification"] = "documentsCrossVerification";
+    WDOStatusCheckReason["clientVerification"] = "clientVerification";
+    WDOStatusCheckReason["clientAccepted"] = "clientAccepted";
+    WDOStatusCheckReason["verifyingPresence"] = "verifyingPresence";
+})(exports.WDOStatusCheckReason || (exports.WDOStatusCheckReason = {}));
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Describes the state of documents that need to be uploaded to the server. */
+var WDOVerificationScanProcess = /** @class */ (function () {
+    /* @internal */
+    function WDOVerificationScanProcess(types) {
+        this.documents = types.map(function (t) { return new WDOScannedDocument(t); });
+    }
+    Object.defineProperty(WDOVerificationScanProcess.prototype, "nextDocumentToScan", {
+        /** Which document should be scanned next. `undefined` when all documents are uploaded and accepted. */
+        get: function () { return this.documents.find(function (d) { return d.uploadState !== exports.UploadState.accepted; }); },
+        enumerable: false,
+        configurable: true
+    });
+    /* @internal */
+    WDOVerificationScanProcess.prototype.feedServerData = function (documents) {
+        var _this = this;
+        var groups = documents.reduce(function (map, doc) {
+            var _a;
+            var key = doc.type;
+            var group = (_a = map.get(key)) !== null && _a !== void 0 ? _a : [];
+            group.push(doc);
+            map.set(key, group);
+            return map;
+        }, new Map());
+        groups.forEach(function (docs, type) {
+            var _a;
+            // TODO: type mismatch?
+            (_a = _this.documents.find(function (d) { return d.type === type; })) === null || _a === void 0 ? void 0 : _a.processServerData(docs);
+        });
+    };
+    return WDOVerificationScanProcess;
+}());
+/** Document that needs to be scanned during process. */
+var WDOScannedDocument = /** @class */ (function () {
+    /* @internal */
+    function WDOScannedDocument(type) {
+        /* @internal */
+        this._sides = new Array();
+        this.type = type;
+    }
+    Object.defineProperty(WDOScannedDocument.prototype, "uploadState", {
+        /** Upload state. */
+        get: function () {
+            // if there are no sides, consider the document not uploaded
+            if (this.sides.length === 0) {
+                return exports.UploadState.notUploaded;
+            }
+            // if any side is rejected, consider whole document rejected
+            for (var _i = 0, _a = this.sides; _i < _a.length; _i++) {
+                var side = _a[_i];
+                if (side.uploadState === exports.UploadState.rejected) {
+                    return exports.UploadState.rejected;
+                }
+            }
+            return exports.UploadState.accepted;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WDOScannedDocument.prototype, "sides", {
+        /** Sides of the document that were uploaded on the server. */
+        get: function () { return this._sides; },
+        enumerable: false,
+        configurable: true
+    });
+    /* @internal */
+    WDOScannedDocument.prototype.processServerData = function (documents) {
+        this._sides = documents.map(function (doc) { var _a, _b; return new Side(doc.side == WDODocumentSubmitFileSide.front ? exports.WDODocumentSide.front : exports.WDODocumentSide.back, doc.id, ((_b = (_a = doc.errors) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0 ? exports.UploadState.rejected : exports.UploadState.accepted); });
+    };
+    return WDOScannedDocument;
+}());
+/** State of the document on the server. */
+exports.UploadState = void 0;
+(function (UploadState) {
+    /** The document was not uploaded yet. */
+    UploadState[UploadState["notUploaded"] = 0] = "notUploaded";
+    /** The document was accepted by the server. */
+    UploadState[UploadState["accepted"] = 1] = "accepted";
+    /** The document was rejected and needs to be re-uploaded. */
+    UploadState[UploadState["rejected"] = 2] = "rejected";
+})(exports.UploadState || (exports.UploadState = {}));
+/** Side of the uploaded document. */
+var Side = /** @class */ (function () {
+    /* @internal */
+    function Side(type, serverId, uploadState) {
+        this.type = type;
+        this.serverId = serverId;
+        this.uploadState = uploadState;
+    }
+    return Side;
+}());
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Service that can verify previously activated PowerAuth instance.
+ *
+ * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
+ * This can be confirmed in the `WDOVerificationService.isVerificationRequired` which will be `true`.
+ *
+ * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
+ */
+var WDOBaseVerificationService = /** @class */ (function () {
+    function WDOBaseVerificationService() {
+        /* @internal */
+        this.lastStatus = undefined;
+        /* @internal */
+        this.cachedProcess = undefined; // TODO: persistence?
+    }
+    // PUBLIC API
+    /**
+     * Accept language for the outgoing requests headers.
+     * Default value is "en".
+     *
+     * Standard RFC "Accept-Language" https://tools.ietf.org/html/rfc7231#section-5.3.5
+     * Response texts are based on this setting. For example when "de" is set, server
+     * will return error texts and other in german (if available).
+     */
+    WDOBaseVerificationService.prototype.changeAcceptLanguage = function (language) {
+        this.changeAcceptLanguageImpl(language);
+    };
+    Object.defineProperty(WDOBaseVerificationService.prototype, "otpResendPeriodSeconds", {
+        /** Time in seconds that user needs to wait between OTP resend calls */
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.lastStatus) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.otpResendPeriodSeconds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Status of the verification.
+     */
+    WDOBaseVerificationService.prototype.status = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, vf, _a, docsResponse, documents, cachedProcess, error_1;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 12, , 13]);
+                        return [4 /*yield*/, this.api.verificationStatus()];
+                    case 1:
+                        response = _c.sent();
+                        WDOLogger.info("Verification status successfully retrieved.");
+                        WDOLogger.debug("Verification status: ".concat(JSON.stringify(response)));
+                        switch (response.identityVerificationStatus) {
+                            case WDOIdentityVerificationStatus.failed:
+                            case WDOIdentityVerificationStatus.rejected:
+                            case WDOIdentityVerificationStatus.notInitialized:
+                            case WDOIdentityVerificationStatus.accepted:
+                                WDOLogger.debug("Status ".concat(response.identityVerificationStatus, " - clearing cache"));
+                                this.cachedProcess = undefined;
+                                break;
+                        }
+                        this.lastStatus = response;
+                        vf = new WDOVerificationStatus(response);
+                        WDOLogger.info("Verification next step: ".concat(vf.description()));
+                        _a = vf.nextStep;
+                        switch (_a) {
+                            case WDONextStep.intro: return [3 /*break*/, 2];
+                            case WDONextStep.documentScan: return [3 /*break*/, 3];
+                            case WDONextStep.presenceCheck: return [3 /*break*/, 5];
+                            case WDONextStep.otp: return [3 /*break*/, 6];
+                            case WDONextStep.statusCheck: return [3 /*break*/, 7];
+                            case WDONextStep.failed: return [3 /*break*/, 8];
+                            case WDONextStep.rejected: return [3 /*break*/, 9];
+                            case WDONextStep.success: return [3 /*break*/, 10];
+                        }
+                        return [3 /*break*/, 11];
+                    case 2: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.intro })];
+                    case 3:
+                        WDOLogger.debug("Verifying documents status");
+                        return [4 /*yield*/, this.api.verificationDocumentsStatus(response.processId)];
+                    case 4:
+                        docsResponse = _c.sent();
+                        WDOLogger.debug("Documents status: ".concat(JSON.stringify(docsResponse)));
+                        documents = docsResponse.documents;
+                        cachedProcess = this.cachedProcess;
+                        if (cachedProcess) {
+                            cachedProcess.feedServerData(docsResponse.documents);
+                            if (documents.some(function (d) { return documentAction(d) === "error"; }) || documents.some(function (d) { return d.errors != undefined && d.errors.length > 0; })) {
+                                WDOLogger.debug("At least one document in error state: ".concat(documents.some(function (d) { return documentAction(d) === "error"; }), ", ").concat(documents.some(function (d) { return d.errors != undefined && d.errors.length > 0; })));
+                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.scanDocument, process: cachedProcess })];
+                            }
+                            else if (documents.every(function (d) { return documentAction(d) === "proceed"; })) {
+                                WDOLogger.debug("All documents accepted, proceeding");
+                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.scanDocument, process: cachedProcess })];
+                            }
+                            else if (documents.some(function (d) { return documentAction(d) === "wait"; })) {
+                                WDOLogger.debug("At least one document still in progress, moving to processing");
+                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.documentVerification })];
+                            }
+                            else if (documents.length == 0) {
+                                WDOLogger.debug("No documents scanned, scan documents...");
+                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.scanDocument, process: cachedProcess })];
+                            }
+                            else {
+                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.failed })];
+                            }
+                        }
+                        else {
+                            if (documents.length == 0) {
+                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.documentsToScanSelect })];
+                            }
+                            else {
+                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.failed })];
+                            }
+                        }
+                    case 5: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.presenceCheck })];
+                    case 6: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.otp })];
+                    case 7: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: (_b = vf.statusCheckReason) !== null && _b !== void 0 ? _b : exports.WDOStatusCheckReason.unknown })];
+                    case 8: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.failed })];
+                    case 9: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.endState, reason: exports.WDOEndStateReason.rejected })];
+                    case 10: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.success })];
+                    case 11: return [3 /*break*/, 13];
+                    case 12:
+                        error_1 = _c.sent();
+                        WDOLogger.error("Error fetching verification status: ".concat(JSON.stringify(error_1)));
+                        this.lastStatus = undefined;
+                        throw this.processError(error_1);
+                    case 13: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Returns consent text for user to approve. The content of the text depends on the server configuration and might be plain text or HTML.
+     *
+     * Consent text explains how the service will handle his document photos or selfie scans.
+     */
+    WDOBaseVerificationService.prototype.consentGet = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verificationGetConsentText(pid))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.consent, body: response.consentText })];
+                }
+            });
+        });
+    };
+    /**
+     * Approves the consent for this process and starts the activation.
+     */
+    WDOBaseVerificationService.prototype.consentApprove = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verificationResolveConsent(pid, true))];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.handleError(this.api.verificationStart(pid))];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.documentsToScanSelect })];
+                }
+            });
+        });
+    };
+    /**
+     * Get the token for the document scanning SDK, when required.
+     *
+     * This is needed for example for ZenID or BlinkID provider.
+     *
+     * @param challenge Optional challenge provided by the scanning SDK.
+     */
+    WDOBaseVerificationService.prototype.documentsInitSDK = function (challenge) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verificationInitScanSDK(pid, challenge !== null && challenge !== void 0 ? challenge : "-"))]; // TODO: is "-" acceptable?
+                    case 1:
+                        response = _a.sent() // TODO: is "-" acceptable?
+                        ;
+                        return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    /**
+     * Set which documents will be scanned.
+     *
+     * Note that this needs to be in sync what server expects based on the configuration.
+     *
+     * @param types Types of documents to scan.
+     */
+    WDOBaseVerificationService.prototype.documentsSetSelectedTypes = function (types) {
+        return __awaiter(this, void 0, void 0, function () {
+            var process;
+            return __generator(this, function (_a) {
+                WDOLogger.debug("Submitting selected document types: ".concat(types));
+                process = new WDOVerificationScanProcess(types);
+                this.cachedProcess = process;
+                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.scanDocument, process: process })];
+            });
+        });
+    };
+    /**
+     * Upload document files to the server. The order of the documents is up to you.
+     * Make sure that uploaded document are reasonable size so you're not uploading large files.
+     *
+     * If you're uploading the same document file again, you need to include the `originalDocumentId` otherwise it will be rejected by the server.
+     *
+     * @param files Document files to upload.
+     */
+    WDOBaseVerificationService.prototype.documentsSubmit = function (files) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, resubmit, submitFiles;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        resubmit = files.some(function (f) { return f.originalDocumentId != undefined; });
+                        submitFiles = files.map(function (f) {
+                            return {
+                                filename: "".concat(f.type.toLowerCase(), "_").concat(f.side.toLowerCase(), ".jpg"), // TODO: OK?
+                                type: WDOCreateDocumentSubmitFileType(f.type),
+                                side: WDOCreateDocumentSubmitFileSide(f.side),
+                                originalDocumentId: f.originalDocumentId,
+                                data: f.data
+                            };
+                        });
+                        return [4 /*yield*/, this.handleError(this.api.verificationSubmitDocumentsV2(pid, resubmit, submitFiles))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.documentUpload })];
+                }
+            });
+        });
+    };
+    /**
+     * @internal
+     * Upload document files to the server. The order of the documents is up to you.
+     * Make sure that uploaded document are reasonable size so you're not uploading large files.
+     *
+     * If you're uploading the same document file again, you need to include the `originalDocumentId` otherwise it will be rejected by the server.
+     *
+     * @param files Document files to upload.
+     */
+    WDOBaseVerificationService.prototype.documentsSubmitDemo = function (files, zipFolderNameDemo, base64zipDemo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, resubmit, submitFiles;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        resubmit = files.some(function (f) { return f.originalDocumentId != undefined; });
+                        submitFiles = files.map(function (f) {
+                            return {
+                                filename: "".concat(zipFolderNameDemo, "/").concat(f.type.toLowerCase(), "_").concat(f.side.toLowerCase(), ".jpg"),
+                                type: WDOCreateDocumentSubmitFileType(f.type),
+                                side: WDOCreateDocumentSubmitFileSide(f.side),
+                                originalDocumentId: f.originalDocumentId
+                            };
+                        });
+                        return [4 /*yield*/, this.handleError(this.api.verificationSubmitDocuments(pid, base64zipDemo, resubmit, submitFiles))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.documentUpload })];
+                }
+            });
+        });
+    };
+    /**
+     * Initiates the presence check. This returns attributes that are needed to start the 3rd party SDK (if needed).
+     */
+    WDOBaseVerificationService.prototype.presenceCheckInit = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verificationPresenceCheckInit(pid))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, this.processSuccess(response.sessionAttributes)];
+                }
+            });
+        });
+    };
+    /**
+     * Call when presence check was finished in the 3rd party SDK.
+     */
+    WDOBaseVerificationService.prototype.presenceCheckSubmit = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verificationPresenceCheckSubmit(pid))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.verifyingPresence })];
+                }
+            });
+        });
+    };
+    /**
+     * Verification restart. When sucessfully called, intro screen should be presented.
+     */
+    WDOBaseVerificationService.prototype.restartVerification = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verificationCleanup(pid))];
+                    case 1:
+                        _a.sent();
+                        this.cachedProcess = undefined;
+                        WDOLogger.info("Verification process restarted.");
+                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.intro })];
+                }
+            });
+        });
+    };
+    /**
+     * Cancel the whole activation/verification. After this it's no longer possible to call
+     * any API of this library and PowerAuth activation should be removed and activation started again.
+     */
+    WDOBaseVerificationService.prototype.cancelWholeProcess = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verificationCleanup(pid))];
+                    case 1:
+                        _a.sent();
+                        this.cachedProcess = undefined;
+                        WDOLogger.info("Verification process canceled.");
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Verify OTP that user entered as a last step of the verification.
+     *
+     * @param otp OTP that user obtained via other channel (usually SMS or email).
+     */
+    WDOBaseVerificationService.prototype.verifyOTP = function (otp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verifyOTP(pid, otp))];
+                    case 1:
+                        response = _a.sent();
+                        if (response.verified) {
+                            WDOLogger.info("OTP verified successfully.");
+                            return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.unknown })];
+                        }
+                        else {
+                            if (response.remainingAttempts > 0 && response.expired == false) {
+                                WDOLogger.error("OTP verification failed, remaining attempts: ".concat(response.remainingAttempts));
+                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.otp, remainingAttempts: response.remainingAttempts })];
+                            }
+                            else {
+                                WDOLogger.error("OTP verification failed, no remaining attempts or OTP expired");
+                                throw this.processError(new WDOError("OTP verification failed, no remaining attempts or OTP expired"));
+                            }
+                        }
+                }
+            });
+        });
+    };
+    /**
+     * Request OTP resend.
+     *
+     * Since SMS or emails can fail to deliver, use this to send the OTP again.
+     */
+    WDOBaseVerificationService.prototype.resendOTP = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.handleError(this.api.verificationResendOTP(pid))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * @internal
+     * Demo endpoint available only in Wultra Demo systems.
+     *
+     * If the app is running against our demo server, you can retrieve the OTP without needing to send SMS or emails.
+     */
+    WDOBaseVerificationService.prototype.getOTP = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Activation: getting OTP from server (only for testing purposes)");
+                        pid = this.verifyHasActiveProcess();
+                        return [4 /*yield*/, this.api.activationGetOTP(pid, "USER_VERIFICATION")];
+                    case 1: return [2 /*return*/, (_a.sent()).otpCode];
+                }
+            });
+        });
+    };
+    // PRIVATE METHODS
+    /* @internal */
+    WDOBaseVerificationService.prototype.verifyHasActiveProcess = function () {
+        var _a;
+        var pid = (_a = this.lastStatus) === null || _a === void 0 ? void 0 : _a.processId;
+        if (!pid) {
+            WDOLogger.error("Process id not available - did you start the verification process and fetched the status?");
+            throw new WDOError("Process id not available - did you start the verification process and fetched the status?");
+        }
+        return pid;
+    };
+    /* @internal */
+    WDOBaseVerificationService.prototype.processSuccess = function (result) {
+        var _a;
+        if (result.type !== undefined) {
+            (_a = this.listener) === null || _a === void 0 ? void 0 : _a.verificationStatusChanged(this, result);
+        }
+        return result;
+    };
+    /* @internal */
+    WDOBaseVerificationService.prototype.handleError = function (promise) {
+        var _this = this;
+        return promise.catch(function (error) {
+            throw _this.processError(error);
+        });
+    };
+    /* @internal */
+    WDOBaseVerificationService.prototype.processError = function (error) {
+        return __awaiter(this, void 0, void 0, function () {
+            var status_1;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(error.code === "AUTHENTICATION_ERROR")) return [3 /*break*/, 4];
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.fetchActivationStatus()];
+                    case 2:
+                        status_1 = _c.sent();
+                        if (status_1.state !== WDOPowerAuthActivationState.ACTIVE) {
+                            WDOLogger.error("PowerAuth status is not active (status".concat(status_1.state, ") - notifying the delegate and returning and error."));
+                            (_b = this.listener) === null || _b === void 0 ? void 0 : _b.powerAuthActivationStatusChanged(this, status_1);
+                            return [2 /*return*/, new WDOError("PowerAuth activation is not active anymore")];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _c.sent();
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/, error];
+                }
+            });
+        });
+    };
+    return WDOBaseVerificationService;
+}());
+// INTERNAL CLASSES
+/**
+  @internal
+  Internal status that works as a translation layer between server API and SDK API
+*/
+var WDOVerificationStatus = /** @class */ (function () {
+    /** Translation from server status to phone status. */
+    function WDOVerificationStatus(serverResponse) {
+        var phase = serverResponse.identityVerificationPhase;
+        var status = serverResponse.identityVerificationStatus;
+        var nextStep = undefined;
+        var statusCheckReason = undefined;
+        // UNDEFINED PHASE
+        if (phase == undefined) {
+            switch (status) {
+                case WDOIdentityVerificationStatus.notInitialized:
+                    nextStep = WDONextStep.intro;
+                    break;
+                case WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+            }
+        }
+        // DOCUMENT UPLOAD PHASE
+        else if (phase === WDOIdentityVerificationPhase.documentUpload) {
+            switch (status) {
+                case WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.documentScan;
+                    break;
+                case WDOIdentityVerificationStatus.verificationPending:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentVerification;
+                    break;
+                case WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+            }
+        }
+        // DOCUMENT VERIFICATION PHASE
+        else if (phase === WDOIdentityVerificationPhase.documentVerification) {
+            switch (status) {
+                case WDOIdentityVerificationStatus.accepted:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentAccepted;
+                    break;
+                case WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentVerification;
+                    break;
+                case WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+                case WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+            }
+        }
+        // DOCUMENT VERIFICATION FINAL PHASE
+        else if (phase === WDOIdentityVerificationPhase.documentVerificationFinal) {
+            switch (status) {
+                case WDOIdentityVerificationStatus.accepted:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentsCrossVerification;
+                    break;
+                case WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentsCrossVerification;
+                    break;
+                case WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+                case WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+            }
+        }
+        // CLIENT EVALUATION PHASE
+        else if (phase === WDOIdentityVerificationPhase.clientEvaluation) {
+            switch (status) {
+                case WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.clientVerification;
+                    break;
+                case WDOIdentityVerificationStatus.accepted:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.clientAccepted;
+                    break;
+                case WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+                case WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+            }
+        }
+        // PRESENCE CHECK PHASE
+        else if (phase === WDOIdentityVerificationPhase.presenceCheck) {
+            switch (status) {
+                case WDOIdentityVerificationStatus.notInitialized:
+                case WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.presenceCheck;
+                    break;
+                case WDOIdentityVerificationStatus.verificationPending:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.verifyingPresence;
+                    break;
+                case WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+                case WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+            }
+        }
+        // OTP PHASE
+        else if (phase === WDOIdentityVerificationPhase.otp) {
+            switch (status) {
+                case WDOIdentityVerificationStatus.verificationPending:
+                    nextStep = WDONextStep.otp;
+                    break;
+            }
+        }
+        // COMPLETED PHASE
+        else if (phase === WDOIdentityVerificationPhase.completed) {
+            switch (status) {
+                case WDOIdentityVerificationStatus.accepted:
+                    nextStep = WDONextStep.success;
+                    break;
+                case WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+                case WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+            }
+        }
+        if (nextStep == undefined) {
+            WDOLogger.error("Unknown phase/status combo: ".concat(phase !== null && phase !== void 0 ? phase : "nil", ", ").concat(status));
+            nextStep = WDONextStep.failed;
+        }
+        this.nextStep = nextStep;
+        this.statusCheckReason = statusCheckReason;
+    }
+    WDOVerificationStatus.prototype.description = function () {
+        var result = this.nextStep.toString();
+        if (this.statusCheckReason) {
+            result += "(".concat(this.statusCheckReason, ")");
+        }
+        return result;
+    };
+    return WDOVerificationStatus;
+}());
+/* @internal */
+var WDONextStep;
+(function (WDONextStep) {
+    WDONextStep["intro"] = "intro";
+    WDONextStep["documentScan"] = "documentScan";
+    WDONextStep["statusCheck"] = "statusCheck";
+    WDONextStep["presenceCheck"] = "presenceCheck";
+    WDONextStep["otp"] = "otp";
+    WDONextStep["failed"] = "failed";
+    WDONextStep["rejected"] = "rejected";
+    WDONextStep["success"] = "success";
+})(WDONextStep || (WDONextStep = {}));
+function documentAction(document) {
+    switch (document.status) {
+        case WDODocumentStatus.accepted:
+            return "proceed";
+        case WDODocumentStatus.uploadInProgress:
+        case WDODocumentStatus.inProgress:
+        case WDODocumentStatus.verificationPending:
+        case WDODocumentStatus.verificationInProgress:
+            return "wait";
+        case WDODocumentStatus.rejected:
+        case WDODocumentStatus.failed:
+            return "error";
+    }
+    WDOLogger.debug("Unknown document status: ".concat(document.status, " for document ID: ").concat(document.id));
+    return "error"; // fallback
+}
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Service that can verify previously activated PowerAuth instance.
+ *
+ * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
+ *
+ * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
+ */
+var WDOVerificationService = /** @class */ (function (_super) {
+    __extends(WDOVerificationService, _super);
+    /**
+     * Creates service instance
+     *
+     * @param powerauth Configured PowerAuth instance. This instance needs to be without valid activation.
+     * @param baseUrl Base URL of the Wultra Digital Onboarding server. Usually ending with `/enrollment-onboarding-server`.
+     */
+    function WDOVerificationService(powerauth, baseUrl) {
+        var _this = _super.call(this) || this;
+        _this.api = new WDOApi(powerauth, baseUrl);
+        _this.powerauth = powerauth;
+        return _this;
+    }
+    /** Checks if verification is required based on PowerAuth activation status */
+    WDOVerificationService.isVerificationRequired = function (paStatus) {
+        var _a;
+        var flags = (_a = paStatus.customObject) === null || _a === void 0 ? void 0 : _a.activationFlags;
+        return !!flags && flags.some(function (f) { return f === "VERIFICATION_PENDING" || f === "VERIFICATION_IN_PROGRESS"; });
+    };
+    /* @internal */
+    WDOVerificationService.prototype.fetchActivationStatus = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.powerauth.fetchActivationStatus()];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                state: WDOPowerAuthActivationState[result.state],
+                                failCount: result.failCount,
+                                maxFailCount: result.maxFailCount,
+                                remainingAttempts: result.remainingAttempts,
+                                customObject: result.customObject
+                            }];
+                }
+            });
+        });
+    };
+    /* @internal */
+    WDOVerificationService.prototype.changeAcceptLanguageImpl = function (language) {
+        this.api.networking.acceptLanguage = language;
+    };
+    return WDOVerificationService;
+}(WDOBaseVerificationService));
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Service that provides configuration for the Wultra Digital Onboarding SDK. */
+var WDOBaseConfigurationService = /** @class */ (function () {
+    function WDOBaseConfigurationService() {
+    }
+    /**
+     * Fetches configuration for the given process type from the server.
+     *
+     * @param processType Type of the process for which to fetch configuration.
+     * @returns Configuration response from the server.
+     */
+    WDOBaseConfigurationService.prototype.getConfiguration = function (processType) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.api.getConfiguration(processType)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return WDOBaseConfigurationService;
+}());
+
+/**
+ * Copyright Wultra s.r.o.
+ *
+ * This source code is licensed under the Apache License, Version 2.0 license
+ * found in the LICENSE file in the root directory of this source tree.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/** Service that provides configuration for the Wultra Digital Onboarding SDK. */
+var WDOConfigurationService = /** @class */ (function (_super) {
+    __extends(WDOConfigurationService, _super);
+    /**
+     * Creates service instance
+     *
+     * @param powerauth Configured PowerAuth instance.
+     * @param baseUrl Base URL of the Wultra Digital Onboarding server. Usually ending with `/enrollment-onboarding-server`.
+     */
+    function WDOConfigurationService(powerauth, baseUrl) {
+        var _this = _super.call(this) || this;
+        _this.api = new WDOApi(powerauth, baseUrl);
+        _this.powerauth = powerauth;
+        return _this;
+    }
+    return WDOConfigurationService;
+}(WDOBaseConfigurationService));
+
+exports.Side = Side;
+exports.WDOActivationService = WDOActivationService;
+exports.WDOConfigurationService = WDOConfigurationService;
+exports.WDODocumentFile = WDODocumentFile;
+exports.WDODocumentTypeSides = WDODocumentTypeSides;
+exports.WDOLogger = WDOLogger;
+exports.WDOScannedDocument = WDOScannedDocument;
+exports.WDOVerificationScanProcess = WDOVerificationScanProcess;
+exports.WDOVerificationService = WDOVerificationService;
+//# sourceMappingURL=index.js.map