cordova-digital-onboarding 1.0.0 → 1.1.0

package/lib/index.js

@@ -0,0 +1,2267 @@
+'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
+ */
+/** Represent error thrown from a WDO library */
+var WDOError = /** @class */ (function () {
+    /* @internal */
+    function WDOError(reason, message, additionalInfo) {
+        /** Helper to identify this object as a WDOError */
+        this.isWdoError = true;
+        this.reason = reason;
+        this.message = message;
+        this.additionalInfo = additionalInfo;
+    }
+    Object.defineProperty(WDOError.prototype, "allowOnboardingOtpRetry", {
+        /**
+         * Whether retrying OTP is allowed based on remaining attempts.
+         *
+         * This may be filled only when the error reason is `WDOErrorReason.activationFailed`.
+         */
+        get: function () { return this.onboardingOtpRemainingAttempts !== undefined && this.onboardingOtpRemainingAttempts > 0; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WDOError.prototype, "onboardingOtpRemainingAttempts", {
+        /**
+         * Number of remaining OTP attempts during onboarding
+         *
+         * This may be filled only when the error reason is `WDOErrorReason.activationFailed`.
+         */
+        get: function () {
+            var _a, _b, _c, _d;
+            if ((_c = (_b = (_a = this.additionalInfo) === null || _a === void 0 ? void 0 : _a.originalException) === null || _b === void 0 ? void 0 : _b.userInfo) === null || _c === void 0 ? void 0 : _c.responseBody) {
+                try {
+                    var parsedResponse = JSON.parse(this.additionalInfo.originalException.userInfo.responseBody);
+                    return (_d = parsedResponse.remainingAttempts) !== null && _d !== void 0 ? _d : undefined;
+                }
+                catch (_e) {
+                    WDOLogger.error("WDOError.onboardingOtpRemainingAttempts: failed to parse response body");
+                    return undefined;
+                }
+            }
+            else {
+                return undefined;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return WDOError;
+}());
+/** Reasons for WDO errors */
+exports.WDOErrorReason = void 0;
+(function (WDOErrorReason) {
+    /** Network error occurred */
+    WDOErrorReason["networkError"] = "NETWORK_ERROR";
+    /** Activation failed */
+    WDOErrorReason["activationFailed"] = "ACTIVATION_FAILED";
+    /** Process is already in progress - happens when start() is called twice */
+    WDOErrorReason["processAlreadyInProgress"] = "PROCESS_ALREADY_IN_PROGRESS";
+    /** No process is in progress - happens when an operation requires an active process */
+    WDOErrorReason["processNotInProgress"] = "PROCESS_NOT_IN_PROGRESS";
+    /** The PowerAuth instance is already activated when trying to activate it again */
+    WDOErrorReason["powerauthAlreadyActivated"] = "POWERAUTH_ALREADY_ACTIVATED";
+    /** The PowerAuth instance is not activated when trying to use it */
+    WDOErrorReason["powerauthNotActivated"] = "POWERAUTH_NOT_ACTIVATED";
+    /** OTP verification failed */
+    WDOErrorReason["otpFailed"] = "OTP_FAILED";
+})(exports.WDOErrorReason || (exports.WDOErrorReason = {}));
+
+/**
+ * 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 WDODefaultCache = /** @class */ (function () {
+    function WDODefaultCache() {
+    }
+    return WDODefaultCache;
+}());
+
+/**
+ * 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() {
+    }
+    /**
+     * 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.
+     */
+    WDOBaseActivationService.prototype.hasActiveProcess = function () {
+        return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, this.getCachedProcessData()];
+                case 1: return [2 /*return*/, !!(_a.sent())];
+            }
+        }); });
+    };
+    /**
+     * 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);
+    };
+    /* @internal  */
+    WDOBaseActivationService.prototype.cacheKey = function () { return "wdopd_".concat(this.getPAInstanceId()); };
+    /* @internal  */
+    WDOBaseActivationService.prototype.setCachedProcessData = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, WDODefaultCache.instance.set(this.cacheKey(), JSON.stringify(data))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* @internal  */
+    WDOBaseActivationService.prototype.getCachedProcessData = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, WDODefaultCache.instance.get(this.cacheKey())];
+                    case 1:
+                        data = _a.sent();
+                        if (!data) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, JSON.parse(data)];
+                }
+            });
+        });
+    };
+    /* @internal  */
+    WDOBaseActivationService.prototype.processId = function () {
+        return __awaiter(this, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, this.getCachedProcessData()];
+                case 1: return [2 /*return*/, (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.processId];
+            }
+        }); });
+    };
+    // 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 _a, _b, _c, pid, result;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = WDOLogger).debug;
+                        _c = "Getting activation status for processId=".concat;
+                        return [4 /*yield*/, this.processId()];
+                    case 1:
+                        _b.apply(_a, [_c.apply("Getting activation status for processId=", [_d.sent()])]);
+                        return [4 /*yield*/, this.verifyCanStartActivation()];
+                    case 2:
+                        _d.sent();
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
+                    case 3:
+                        pid = _d.sent();
+                        return [4 /*yield*/, this.api.activationGetStatus(pid)];
+                    case 4:
+                        result = _d.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)));
+                        return [4 /*yield*/, this.processId()];
+                    case 1:
+                        if (_a.sent()) {
+                            throw new WDOError(exports.WDOErrorReason.processAlreadyInProgress, "Cannot start the process - processId already obtained, cancel first.");
+                        }
+                        return [4 /*yield*/, this.verifyCanStartActivation()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.api.activationStart(credentials, processType)];
+                    case 3:
+                        result = _a.sent();
+                        WDOLogger.info("WDOActivationService.start success");
+                        WDOLogger.debug(" - processId: ".concat(result.processId));
+                        return [4 /*yield*/, this.setCachedProcessData({ processId: result.processId, activationCode: result.activationCode })];
+                    case 4:
+                        _a.sent();
+                        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 _a, _b, _c, pid, error_1;
+            if (forceCancel === void 0) { forceCancel = true; }
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = WDOLogger).debug;
+                        _c = "Canceling activation for processId=".concat;
+                        return [4 /*yield*/, this.processId()];
+                    case 1:
+                        _b.apply(_a, [_c.apply("Canceling activation for processId=", [_d.sent(), ", forceCancel="]).concat(forceCancel)]);
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
+                    case 2:
+                        pid = _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _d.trys.push([3, 6, , 10]);
+                        return [4 /*yield*/, this.api.activationCancel(pid)];
+                    case 4:
+                        _d.sent();
+                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 5:
+                        _d.sent();
+                        WDOLogger.info("WDOActivationService.cancel success");
+                        return [3 /*break*/, 10];
+                    case 6:
+                        error_1 = _d.sent();
+                        if (!forceCancel) return [3 /*break*/, 8];
+                        // pretend it was successful and just log the error
+                        WDOLogger.debug("Process canceled (but the request failed) - ".concat(error_1, "."));
+                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 7:
+                        _d.sent();
+                        return [3 /*break*/, 9];
+                    case 8: throw error_1; // rethrow
+                    case 9: return [3 /*break*/, 10];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Clear the stored data (without networking call). */
+    WDOBaseActivationService.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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");
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
+                    case 1:
+                        pid = _a.sent();
+                        return [4 /*yield*/, this.verifyCanStartActivation()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.api.activationResendOTP(pid)];
+                    case 3:
+                        _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)");
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
+                    case 1:
+                        pid = _a.sent();
+                        return [4 /*yield*/, this.api.activationGetOTP(pid, "ACTIVATION")];
+                    case 2: return [2 /*return*/, (_a.sent()).otpCode];
+                }
+            });
+        });
+    };
+    /**
+     * Activate the PowerAuth instance that was passed in the initializer.
+     *
+     * @param activationName Name of the activation. 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, error_2;
+            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.verifyCanStartActivation()];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
+                    case 2:
+                        pid = _b.sent();
+                        return [4 /*yield*/, this.getCachedProcessData()];
+                    case 3:
+                        code = (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.activationCode;
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 9, , 10]);
+                        if (!code) return [3 /*break*/, 6];
+                        WDOLogger.info("Activating PowerAuth using activation code from the onboarding process");
+                        return [4 /*yield*/, this.activatePowerAuthWithCode(code, otp, activationName)];
+                    case 5:
+                        result = _b.sent();
+                        return [3 /*break*/, 8];
+                    case 6:
+                        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 7:
+                        result = _b.sent();
+                        _b.label = 8;
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        error_2 = _b.sent();
+                        throw new WDOError(exports.WDOErrorReason.activationFailed, "Activation failed", error_2);
+                    case 10: 
+                    // Clear process ID after activation attempt
+                    return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 11:
+                        // Clear process ID after activation attempt
+                        _b.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    // PRIVATE METHODS
+    /* @internal */
+    WDOBaseActivationService.prototype.verifyCanStartActivation = 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())) return [3 /*break*/, 3];
+                        WDOLogger.error("PowerAuth is already activated - Activation cannot be started/processed.");
+                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 2:
+                        _a.sent();
+                        throw new WDOError(exports.WDOErrorReason.powerauthAlreadyActivated, "PowerAuth is already activated");
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* @internal */
+    WDOBaseActivationService.prototype.verifyHasActiveProcess = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.processId()];
+                    case 1:
+                        pid = _a.sent();
+                        if (!pid) {
+                            WDOLogger.warn("Cannot proceed (processId not available).");
+                            throw new WDOError(exports.WDOErrorReason.processNotInProgress, "No active activation process");
+                        }
+                        return [2 /*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
+    };
+    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" };
+        return this.callApi(requestObject, WDOVerificationEndpoints.consentText);
+    };
+    WDOBaseApi.prototype.verificationResolveConsent = function (processId, approved) {
+        var requestObject = { processId: processId, approved: approved, consentType: "GDPR" };
+        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.verificationSubmitDocuments = 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.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(exports.WDOErrorReason.networkError, "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(exports.WDOErrorReason.networkError, "Failed to retrieve server 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;
+    };
+    /* @internal */
+    WDOActivationService.prototype.getPAInstanceId = function () {
+        return this.powerauth.instanceId;
+    };
+    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
+ */
+/** Status of the onboarding */
+exports.WDOOnboardingStatus = void 0;
+(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";
+})(exports.WDOOnboardingStatus || (exports.WDOOnboardingStatus = {}));
+/** Status of the current identity verification */
+exports.WDOIdentityVerificationStatus = void 0;
+(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";
+})(exports.WDOIdentityVerificationStatus || (exports.WDOIdentityVerificationStatus = {}));
+/** Phase of the current identity verification */
+exports.WDOIdentityVerificationPhase = void 0;
+(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";
+})(exports.WDOIdentityVerificationPhase || (exports.WDOIdentityVerificationPhase = {}));
+/** Types of available documents */
+exports.WDODocumentSubmitFileType = void 0;
+(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";
+})(exports.WDODocumentSubmitFileType || (exports.WDODocumentSubmitFileType = {}));
+/** Side of the file */
+exports.WDODocumentSubmitFileSide = void 0;
+(function (WDODocumentSubmitFileSide) {
+    /** Front side of an document. Usually the one with the picture */
+    WDODocumentSubmitFileSide["front"] = "FRONT";
+    /** Back side of an document */
+    WDODocumentSubmitFileSide["back"] = "BACK";
+})(exports.WDODocumentSubmitFileSide || (exports.WDODocumentSubmitFileSide = {}));
+/** Status of the document */
+exports.WDODocumentStatus = void 0;
+(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";
+})(exports.WDODocumentStatus || (exports.WDODocumentStatus = {}));
+
+/**
+ * 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 `start()`.
+     */
+    WDOVerificationStateType["intro"] = "intro";
+    /**
+     * 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
+ */
+/** 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 = {}));
+/** Converts WDODocumentType to WDODocumentSubmitFileType */
+function WDODocumentTypeToSubmitType(type) {
+    switch (type) {
+        case exports.WDODocumentType.idCard:
+            return exports.WDODocumentSubmitFileType.idCard;
+        case exports.WDODocumentType.passport:
+            return exports.WDODocumentSubmitFileType.passport;
+        case exports.WDODocumentType.driversLicense:
+            return exports.WDODocumentSubmitFileType.driversLicense;
+    }
+}
+/** Converts WDODocumentSide to DocumentSubmitFileSide */
+function WDOCreateDocumentSubmitFileSide(side) {
+    switch (side) {
+        case exports.WDODocumentSide.front:
+            return exports.WDODocumentSubmitFileSide.front;
+        case exports.WDODocumentSide.back:
+            return exports.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
+ */
+/** 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;
+            (_a = _this.documents.find(function (d) { return WDODocumentTypeToSubmitType(d.type) === type; })) === null || _a === void 0 ? void 0 : _a.processServerData(docs);
+        });
+    };
+    /* @internal */
+    WDOVerificationScanProcess.fromCachedData = function (data) {
+        var split = data.split(":");
+        if (split.length != 2) {
+            WDOLogger.error("WDOVerificationScanProcess.fromCachedData: invalid cached data format");
+            return undefined;
+        }
+        if (split[0] !== "v1") {
+            WDOLogger.error("WDOVerificationScanProcess.fromCachedData: unsupported cached data version");
+            return undefined;
+        }
+        var types = split[1].split(",").map(function (s) { return s; });
+        return new WDOVerificationScanProcess(types);
+    };
+    /* @internal */
+    WDOVerificationScanProcess.prototype.dataForCache = function () {
+        return "v1:".concat(this.documents.map(function (d) { return d.type; }).join(","));
+    };
+    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 == exports.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
+ */
+/** Possible results of the user consent. */
+exports.WDOConsentResponse = void 0;
+(function (WDOConsentResponse) {
+    /** User approved the consent. */
+    WDOConsentResponse[WDOConsentResponse["approved"] = 0] = "approved";
+    /** User declined the consent. */
+    WDOConsentResponse[WDOConsentResponse["declined"] = 1] = "declined";
+    /** Consent is not required. */
+    WDOConsentResponse[WDOConsentResponse["notRequired"] = 2] = "notRequired";
+})(exports.WDOConsentResponse || (exports.WDOConsentResponse = {}));
+/**
+ * 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 */
+    WDOBaseVerificationService.prototype.cacheKey = function () { return "wdocp_".concat(this.getPAInstanceId()); };
+    /* @internal */
+    WDOBaseVerificationService.prototype.setCachedProcess = function (process) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, WDODefaultCache.instance.set(this.cacheKey(), process === null || process === void 0 ? void 0 : process.dataForCache())];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* @internal */
+    WDOBaseVerificationService.prototype.getCachedProcess = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, WDODefaultCache.instance.get(this.cacheKey())];
+                    case 1:
+                        data = _a.sent();
+                        if (!data) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, WDOVerificationScanProcess.fromCachedData(data)];
+                }
+            });
+        });
+    };
+    // 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, _a, vf, _b, docsResponse, documents, cachedProcess, error_1;
+            var _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _e.trys.push([0, 17, , 18]);
+                        return [4 /*yield*/, this.api.verificationStatus()];
+                    case 1:
+                        response = _e.sent();
+                        response.consentRequired = (_c = response.consentRequired) !== null && _c !== void 0 ? _c : false; // when undefined, assume false
+                        WDOLogger.info("Verification status successfully retrieved.");
+                        WDOLogger.debug("Verification status: ".concat(JSON.stringify(response)));
+                        _a = response.identityVerificationStatus;
+                        switch (_a) {
+                            case exports.WDOIdentityVerificationStatus.failed: return [3 /*break*/, 2];
+                            case exports.WDOIdentityVerificationStatus.rejected: return [3 /*break*/, 2];
+                            case exports.WDOIdentityVerificationStatus.notInitialized: return [3 /*break*/, 2];
+                            case exports.WDOIdentityVerificationStatus.accepted: return [3 /*break*/, 2];
+                        }
+                        return [3 /*break*/, 4];
+                    case 2:
+                        WDOLogger.debug("Status ".concat(response.identityVerificationStatus, " - clearing cache"));
+                        return [4 /*yield*/, this.setCachedProcess(undefined)];
+                    case 3:
+                        _e.sent();
+                        return [3 /*break*/, 5];
+                    case 4: 
+                    // no-op
+                    return [3 /*break*/, 5];
+                    case 5:
+                        this.lastStatus = response;
+                        vf = new WDOVerificationStatus(response);
+                        WDOLogger.info("Verification next step: ".concat(vf.description()));
+                        _b = vf.nextStep;
+                        switch (_b) {
+                            case WDONextStep.intro: return [3 /*break*/, 6];
+                            case WDONextStep.documentScan: return [3 /*break*/, 7];
+                            case WDONextStep.presenceCheck: return [3 /*break*/, 10];
+                            case WDONextStep.otp: return [3 /*break*/, 11];
+                            case WDONextStep.statusCheck: return [3 /*break*/, 12];
+                            case WDONextStep.failed: return [3 /*break*/, 13];
+                            case WDONextStep.rejected: return [3 /*break*/, 14];
+                            case WDONextStep.success: return [3 /*break*/, 15];
+                        }
+                        return [3 /*break*/, 16];
+                    case 6: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.intro, consentRequired: response.consentRequired })];
+                    case 7:
+                        WDOLogger.debug("Verifying documents status");
+                        return [4 /*yield*/, this.api.verificationDocumentsStatus(response.processId)];
+                    case 8:
+                        docsResponse = _e.sent();
+                        WDOLogger.debug("Documents status: ".concat(JSON.stringify(docsResponse)));
+                        documents = docsResponse.documents;
+                        return [4 /*yield*/, this.getCachedProcess()];
+                    case 9:
+                        cachedProcess = _e.sent();
+                        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 10: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.presenceCheck })];
+                    case 11: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.otp })];
+                    case 12: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: (_d = vf.statusCheckReason) !== null && _d !== void 0 ? _d : exports.WDOStatusCheckReason.unknown })];
+                    case 13: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.failed })];
+                    case 14: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.endState, reason: exports.WDOEndStateReason.rejected })];
+                    case 15: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.success })];
+                    case 16: return [3 /*break*/, 18];
+                    case 17:
+                        error_1 = _e.sent();
+                        WDOLogger.error("Error fetching verification status: ".concat(JSON.stringify(error_1)));
+                        this.lastStatus = undefined;
+                        throw this.processError(error_1);
+                    case 18: 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*/, response.consentText];
+                }
+            });
+        });
+    };
+    /**
+     * Start the identity verification after user approved the consent (if required)
+     *
+     * @param consentApprovedByUser Response of the user to the consent. The hint can be obtained in the `status()` call (`consentRequired` property when the result is `intro`).
+     */
+    WDOBaseVerificationService.prototype.start = function (consentApprovedByUser) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, _a;
+            var _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        pid = this.verifyHasActiveProcess();
+                        _a = consentApprovedByUser;
+                        switch (_a) {
+                            case exports.WDOConsentResponse.approved: return [3 /*break*/, 1];
+                            case exports.WDOConsentResponse.declined: return [3 /*break*/, 3];
+                            case exports.WDOConsentResponse.notRequired: return [3 /*break*/, 5];
+                        }
+                        return [3 /*break*/, 6];
+                    case 1:
+                        WDOLogger.info("User approved consent - resolving on server");
+                        return [4 /*yield*/, this.handleError(this.api.verificationResolveConsent(pid, true))];
+                    case 2:
+                        _d.sent();
+                        return [3 /*break*/, 6];
+                    case 3:
+                        WDOLogger.info("User declined consent - returning to intro state");
+                        return [4 /*yield*/, this.handleError(this.api.verificationResolveConsent(pid, false))];
+                    case 4:
+                        _d.sent();
+                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.intro, consentRequired: (_c = (_b = this.lastStatus) === null || _b === void 0 ? void 0 : _b.consentRequired) !== null && _c !== void 0 ? _c : true })]; // TODO: ok to assume true?
+                    case 5:
+                        WDOLogger.info("Consent not required - proceeding");
+                        _d.label = 6;
+                    case 6: return [4 /*yield*/, this.handleError(this.api.verificationStart(pid))];
+                    case 7:
+                        _d.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, blinkID, zenId;
+            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?
+                        ;
+                        blinkID = response.attributes["license-key"];
+                        zenId = response.attributes["zenid-sdk-init-response"];
+                        return [2 /*return*/, { blinkIDKey: blinkID, zenIDToken: zenId }];
+                }
+            });
+        });
+    };
+    /**
+     * 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) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Submitting selected document types: ".concat(types));
+                        process = new WDOVerificationScanProcess(types);
+                        return [4 /*yield*/, this.setCachedProcess(process)];
+                    case 1:
+                        _a.sent();
+                        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"),
+                                type: WDODocumentTypeToSubmitType(f.type),
+                                side: WDOCreateDocumentSubmitFileSide(f.side),
+                                originalDocumentId: f.originalDocumentId,
+                                data: f.data
+                            };
+                        });
+                        return [4 /*yield*/, this.handleError(this.api.verificationSubmitDocuments(pid, 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();
+                        return [4 /*yield*/, this.setCachedProcess(undefined)];
+                    case 2:
+                        _a.sent();
+                        WDOLogger.info("Verification process restarted.");
+                        return [4 /*yield*/, this.status()];
+                    case 3: 
+                    // return new status
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * 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();
+                        return [4 /*yield*/, this.setCachedProcess(undefined)];
+                    case 2:
+                        _a.sent();
+                        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(exports.WDOErrorReason.otpFailed, "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(exports.WDOErrorReason.processNotInProgress, "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(exports.WDOErrorReason.powerauthNotActivated, "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 exports.WDOIdentityVerificationStatus.notInitialized:
+                    nextStep = WDONextStep.intro;
+                    break;
+                case exports.WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+            }
+        }
+        // DOCUMENT UPLOAD PHASE
+        else if (phase === exports.WDOIdentityVerificationPhase.documentUpload) {
+            switch (status) {
+                case exports.WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.documentScan;
+                    break;
+                case exports.WDOIdentityVerificationStatus.verificationPending:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentVerification;
+                    break;
+                case exports.WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+            }
+        }
+        // DOCUMENT VERIFICATION PHASE
+        else if (phase === exports.WDOIdentityVerificationPhase.documentVerification) {
+            switch (status) {
+                case exports.WDOIdentityVerificationStatus.accepted:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentAccepted;
+                    break;
+                case exports.WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentVerification;
+                    break;
+                case exports.WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+                case exports.WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+            }
+        }
+        // DOCUMENT VERIFICATION FINAL PHASE
+        else if (phase === exports.WDOIdentityVerificationPhase.documentVerificationFinal) {
+            switch (status) {
+                case exports.WDOIdentityVerificationStatus.accepted:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentsCrossVerification;
+                    break;
+                case exports.WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.documentsCrossVerification;
+                    break;
+                case exports.WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+                case exports.WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+            }
+        }
+        // CLIENT EVALUATION PHASE
+        else if (phase === exports.WDOIdentityVerificationPhase.clientEvaluation) {
+            switch (status) {
+                case exports.WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.clientVerification;
+                    break;
+                case exports.WDOIdentityVerificationStatus.accepted:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.clientAccepted;
+                    break;
+                case exports.WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+                case exports.WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+            }
+        }
+        // PRESENCE CHECK PHASE
+        else if (phase === exports.WDOIdentityVerificationPhase.presenceCheck) {
+            switch (status) {
+                case exports.WDOIdentityVerificationStatus.notInitialized:
+                case exports.WDOIdentityVerificationStatus.inProgress:
+                    nextStep = WDONextStep.presenceCheck;
+                    break;
+                case exports.WDOIdentityVerificationStatus.verificationPending:
+                    nextStep = WDONextStep.statusCheck;
+                    statusCheckReason = exports.WDOStatusCheckReason.verifyingPresence;
+                    break;
+                case exports.WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+                case exports.WDOIdentityVerificationStatus.rejected:
+                    nextStep = WDONextStep.rejected;
+                    break;
+            }
+        }
+        // OTP PHASE
+        else if (phase === exports.WDOIdentityVerificationPhase.otp) {
+            switch (status) {
+                case exports.WDOIdentityVerificationStatus.verificationPending:
+                    nextStep = WDONextStep.otp;
+                    break;
+            }
+        }
+        // COMPLETED PHASE
+        else if (phase === exports.WDOIdentityVerificationPhase.completed) {
+            switch (status) {
+                case exports.WDOIdentityVerificationStatus.accepted:
+                    nextStep = WDONextStep.success;
+                    break;
+                case exports.WDOIdentityVerificationStatus.failed:
+                    nextStep = WDONextStep.failed;
+                    break;
+                case exports.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 exports.WDODocumentStatus.accepted:
+            return "proceed";
+        case exports.WDODocumentStatus.uploadInProgress:
+        case exports.WDODocumentStatus.inProgress:
+        case exports.WDODocumentStatus.verificationPending:
+        case exports.WDODocumentStatus.verificationInProgress:
+            return "wait";
+        case exports.WDODocumentStatus.rejected:
+        case exports.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;
+    };
+    /* @internal */
+    WDOVerificationService.prototype.getPAInstanceId = function () {
+        return this.powerauth.instanceId;
+    };
+    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));
+
+/**
+ * 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 WDOCordovaCache = /** @class */ (function () {
+    function WDOCordovaCache() {
+    }
+    WDOCordovaCache.prototype.set = function (key, value) {
+        if (value) {
+            return PowerAuthStorageUtils.setString(key, value, PowerAuthStorageType.SECURE);
+        }
+        else {
+            return PowerAuthStorageUtils.remove(key, PowerAuthStorageType.SECURE).then(function () { });
+        }
+    };
+    WDOCordovaCache.prototype.get = function (key) {
+        return PowerAuthStorageUtils.getString(key, PowerAuthStorageType.SECURE);
+    };
+    WDOCordovaCache.prototype.has = function (key) {
+        return PowerAuthStorageUtils.exists(key, PowerAuthStorageType.SECURE);
+    };
+    return WDOCordovaCache;
+}());
+
+/**
+ * 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
+ */
+WDODefaultCache.instance = new WDOCordovaCache();
+
+exports.Side = Side;
+exports.WDOActivationService = WDOActivationService;
+exports.WDOConfigurationService = WDOConfigurationService;
+exports.WDOCreateDocumentSubmitFileSide = WDOCreateDocumentSubmitFileSide;
+exports.WDODocumentFile = WDODocumentFile;
+exports.WDODocumentTypeSides = WDODocumentTypeSides;
+exports.WDODocumentTypeToSubmitType = WDODocumentTypeToSubmitType;
+exports.WDOError = WDOError;
+exports.WDOLogger = WDOLogger;
+exports.WDOScannedDocument = WDOScannedDocument;
+exports.WDOVerificationScanProcess = WDOVerificationScanProcess;
+exports.WDOVerificationService = WDOVerificationService;
+//# sourceMappingURL=index.js.map