cordova-digital-onboarding 1.0.1 → 1.2.0

package/lib/index.js

@@ -74,6 +74,232 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     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
+ */
+/** 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";
+    /**
+     * Show "finish activation" with PIN prompt screen.
+     *
+     * The next step should be calling the `finishActivation` with user entered PIN.
+     */
+    WDOVerificationStateType["finishActivation"] = "finishActivation";
+    /**
+     * 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
+ */
+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
+    };
+    WDOVerificationEndpoints.finishActivation = {
+        path: "/api/identity/activation",
+        tokenName: "possession_universal",
+        e2eeScope: "ACTIVATION",
+        returnsData: true
+    };
+    return WDOVerificationEndpoints;
+}());
+
 /**
  * Copyright Wultra s.r.o.
  *
@@ -135,14 +361,75 @@ var WDOLogger = /** @class */ (function () {
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-// TODO: add ERROR codes
+/** Represent error thrown from a WDO library */
 var WDOError = /** @class */ (function () {
-    function WDOError(message, additionalInfo) {
+    /* @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 configured properly */
+    WDOErrorReason["powerAuthNotConfigured"] = "POWERAUTH_NOT_CONFIGURED";
+    /** The PowerAuth instance is not activated when trying to use it */
+    WDOErrorReason["powerauthNotActivated"] = "POWERAUTH_NOT_ACTIVATED";
+    /** OTP verification failed */
+    WDOErrorReason["otpFailed"] = "OTP_FAILED";
+    /** Invalid parameter */
+    WDOErrorReason["invalidParameter"] = "INVALID_PARAMETER";
+})(exports.WDOErrorReason || (exports.WDOErrorReason = {}));
 
 /**
  * Copyright Wultra s.r.o.
@@ -152,548 +439,157 @@ var WDOError = /** @class */ (function () {
  *
  * SPDX-License-Identifier: Apache-2.0
  */
+var WDOPlatform = /** @class */ (function () {
+    function WDOPlatform() {
+    }
+    return WDOPlatform;
+}());
+
 /**
- * Service that can activate PowerAuth instance by user weak credentials (like his email, phone number or client ID) + optional SMS OTP.
+ * Copyright Wultra s.r.o.
  *
- * 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 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.
  *
- * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
+ * SPDX-License-Identifier: Apache-2.0
  */
-var WDOBaseActivationService = /** @class */ (function () {
-    function WDOBaseActivationService() {
+var WDOApi = /** @class */ (function () {
+    function WDOApi(powerauth, baseUrl) {
+        // TODO: additional configuration?
+        this.networking = WDOPlatform.networkingFactory.networking(powerauth, baseUrl);
     }
-    Object.defineProperty(WDOBaseActivationService.prototype, "hasActiveProcess", {
-        /**
-         * If the activation process is in progress.
-         *
-         * Note that even if this property is `true` it can be already discontinued on the server.
-         * Calling `status()` for example after the app is launched in this case is recommended.
-         */
-        get: function () { return !!this.processData; },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Accept language for the outgoing requests headers.
-     * Default value is "en".
-     *
-     * Standard RFC "Accept-Language" https://tools.ietf.org/html/rfc7231#section-5.3.5
-     * Response texts are based on this setting. For example when "de" is set, server
-     * will return error texts and other in german (if available).
-     */
-    WDOBaseActivationService.prototype.changeAcceptLanguage = function (language) {
-        this.changeAcceptLanguageImpl(language);
+    // Configuration endpoints
+    WDOApi.prototype.getConfiguration = function (processType) {
+        var requestObject = { processType: processType };
+        return this.callApi(requestObject, { path: "/api/configuration", e2eeScope: "APPLICATION", returnsData: true });
     };
-    Object.defineProperty(WDOBaseActivationService.prototype, "processId", {
-        /* @internal  */
-        get: function () { var _a; return (_a = this.processData) === null || _a === void 0 ? void 0 : _a.processId; },
-        enumerable: false,
-        configurable: true
-    });
-    // PUBLIC API
-    /**
-     * Retrieves status of the onboarding activation.
-     *
-     * @return Promise resolved with onboarding status.
-     */
-    WDOBaseActivationService.prototype.status = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid, result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WDOLogger.debug("Getting activation status for processId=".concat(this.processId));
-                        return [4 /*yield*/, this.verifyCanStartProcess()];
-                    case 1:
-                        _a.sent();
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.api.activationGetStatus(pid)];
-                    case 2:
-                        result = _a.sent();
-                        return [2 /*return*/, result.onboardingStatus];
-                }
-            });
-        });
+    // Activation endpoints
+    WDOApi.prototype.activationStart = function (credentials, processType) {
+        var requestObject = { identification: credentials, processType: processType };
+        return this.callApi(requestObject, WDOActivationEndpoints.start);
     };
-    /**
-     * Start onboarding activation with user credentials.
-     *
-     * For example, when you require email and birth date, your object would look like this:
-     * ```
-     * {
-     *   email: "<user_email>",
-     *   birthdate: "<user_birth_date>"
-     * }
-     * ```
-     * @param credentials Object with credentials. Which credentials are needed should be provided by a system/backend provider.
-     * @param processType The process type identification. If not specified, the default process type will be used.
-     */
-    WDOBaseActivationService.prototype.start = function (credentials, processType) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WDOLogger.debug("Starting activation with credentials: ".concat(JSON.stringify(credentials)));
-                        if (this.processId) {
-                            throw new WDOError("Cannot start the process - processId already obtained, cancel first.");
-                        }
-                        return [4 /*yield*/, this.verifyCanStartProcess()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.api.activationStart(credentials, processType)];
-                    case 2:
-                        result = _a.sent();
-                        WDOLogger.info("WDOActivationService.start success");
-                        WDOLogger.debug(" - processId: ".concat(result.processId));
-                        this.processData = { processId: result.processId, activationCode: result.activationCode };
-                        return [2 /*return*/];
-                }
-            });
-        });
+    WDOApi.prototype.activationCancel = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOActivationEndpoints.cancel);
     };
-    /**
-     * Cancel the activation process (issues a cancel request to the backend and clears the local process ID).
-     *
-     * @param forceCancel When true, the process will be canceled in the SDK even when fails on backend. `true` by default.
-     */
-    WDOBaseActivationService.prototype.cancel = function () {
-        return __awaiter(this, arguments, void 0, function (forceCancel) {
-            var pid, error_1;
-            if (forceCancel === void 0) { forceCancel = true; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WDOLogger.debug("Canceling activation for processId=".concat(this.processId, ", forceCancel=").concat(forceCancel));
-                        pid = this.verifyHasActiveProcess();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.api.activationCancel(pid)];
-                    case 2:
-                        _a.sent();
-                        this.processData = undefined;
-                        WDOLogger.info("WDOActivationService.cancel success");
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _a.sent();
-                        if (forceCancel) {
-                            // pretend it was successful and just log the error
-                            WDOLogger.debug("Process canceled (but the request failed) - ".concat(error_1, "."));
-                            this.processData = undefined;
-                        }
-                        else {
-                            throw error_1; // rethrow
-                        }
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
+    WDOApi.prototype.activationGetStatus = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOActivationEndpoints.getStatus);
     };
-    /** Clear the stored data (without networking call). */
-    WDOBaseActivationService.prototype.clear = function () {
-        this.processData = undefined;
+    WDOApi.prototype.activationResendOTP = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOActivationEndpoints.resendOTP);
     };
-    /**
-     * OTP resend request.
-     *
-     * This is intended to be displayed for the user to use in case of the OTP is not received.
-     * For example, when the user does not receive SMS after some time, there should be a button to "send again".
-     */
-    WDOBaseActivationService.prototype.resendOTP = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WDOLogger.debug("Activation: resending OTP");
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.verifyCanStartProcess()];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.api.activationResendOTP(pid)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
+    WDOApi.prototype.activationGetOTP = function (processId, otpType) {
+        var requestObject = { processId: processId, otpType: otpType };
+        return this.callApi(requestObject, { path: "/api/onboarding/otp/detail", e2eeScope: "APPLICATION", returnsData: true });
     };
-    /**
-     * @internal
-     * Demo endpoint available only in Wultra Demo systems.
-     *
-     * If the app is running against our demo server, you can retrieve the OTP without needing to send SMS or emails.
-     */
-    WDOBaseActivationService.prototype.getOTP = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WDOLogger.debug("Activation: getting OTP from server (only for testing purposes)");
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.api.activationGetOTP(pid, "ACTIVATION")];
-                    case 1: return [2 /*return*/, (_a.sent()).otpCode];
-                }
-            });
-        });
+    // Verification endpoints
+    WDOApi.prototype.verificationStatus = function () {
+        var requestObject = {};
+        return this.callApi(requestObject, WDOVerificationEndpoints.getStatus);
     };
-    /**
-     * Activate the PowerAuth instance that was passed in the initializer.
-     *
-     * @param activationName Name of the activation. Device name by default (usually something like John's iPhone or similar).
-     * @param otp OTP code received by the user (via SMS or email). Optional when not required.
-     * @return Promise resolved with activation result.
-     */
-    WDOBaseActivationService.prototype.activate = function (activationName, otp) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid, code, result, identityAttributes;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        WDOLogger.debug("Activating the PowerAuth with activation name '".concat(activationName, "'"));
-                        return [4 /*yield*/, this.verifyCanStartProcess()];
-                    case 1:
-                        _b.sent();
-                        pid = this.verifyHasActiveProcess();
-                        code = (_a = this.processData) === null || _a === void 0 ? void 0 : _a.activationCode;
-                        if (!code) return [3 /*break*/, 3];
-                        WDOLogger.info("Activating PowerAuth using activation code from the onboarding process");
-                        return [4 /*yield*/, this.activatePowerAuthWithCode(code, otp, activationName)];
-                    case 2:
-                        result = _b.sent();
-                        return [3 /*break*/, 5];
-                    case 3:
-                        WDOLogger.info("Activating PowerAuth using identity attributes from the onboarding process");
-                        identityAttributes = { processId: pid, otpCode: otp, credentialsType: "ONBOARDING" };
-                        return [4 /*yield*/, this.activatePowerAuth(identityAttributes, activationName)];
-                    case 4:
-                        result = _b.sent();
-                        _b.label = 5;
-                    case 5:
-                        // Clear process ID after activation attempt
-                        this.processData = undefined;
-                        return [2 /*return*/, result];
-                }
-            });
-        });
+    WDOApi.prototype.verificationStart = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOVerificationEndpoints.init);
     };
-    // PRIVATE METHODS
-    /* @internal */
-    WDOBaseActivationService.prototype.verifyCanStartProcess = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.api.canStartActivation()];
-                    case 1:
-                        if (!(_a.sent())) {
-                            WDOLogger.error("PowerAuth is already activated - Activation cannot be started/processed.");
-                            this.processData = undefined;
-                            throw new WDOError("PowerAuth is already activated");
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
+    WDOApi.prototype.verificationCleanup = function (processId) {
+        var requestObject = { processId: processId };
+        return this.callApi(requestObject, WDOVerificationEndpoints.cancel);
     };
-    /* @internal */
-    WDOBaseActivationService.prototype.verifyHasActiveProcess = function () {
-        var pid = this.processId;
-        if (!pid) {
-            WDOLogger.warn("Cannot proceed (processId not available).");
-            throw new WDOError("No active activation process");
-        }
-        return pid;
+    WDOApi.prototype.verificationGetConsentText = function (processId) {
+        var requestObject = { processId: processId, consentType: "GDPR" };
+        return this.callApi(requestObject, WDOVerificationEndpoints.consentText);
     };
-    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
+    WDOApi.prototype.verificationResolveConsent = function (processId, approved) {
+        var requestObject = { processId: processId, approved: approved, consentType: "GDPR" };
+        return this.callApi(requestObject, WDOVerificationEndpoints.consentApprove);
     };
-    WDOActivationEndpoints.cancel = {
-        path: "/api/onboarding/cleanup",
-        e2eeScope: "APPLICATION",
-        returnsData: false
+    WDOApi.prototype.verificationInitScanSDK = function (processId, challenge) {
+        var requestObject = { processId: processId, attributes: { 'sdk-init-token': challenge } };
+        return this.callApi(requestObject, WDOVerificationEndpoints.documentScanSdkInit);
     };
-    WDOActivationEndpoints.resendOTP = {
-        path: "/api/onboarding/otp/resend",
-        e2eeScope: "APPLICATION",
-        returnsData: false
+    WDOApi.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);
     };
-    WDOActivationEndpoints.getStatus = {
-        path: "/api/onboarding/status",
-        e2eeScope: "APPLICATION",
-        returnsData: true
+    WDOApi.prototype.verificationDocumentsStatus = function (processId) {
+        var requestObject = { processId: processId };
+        // TODO: longer timeout?
+        return this.callApi(requestObject, WDOVerificationEndpoints.documentsStatus);
     };
-    return WDOActivationEndpoints;
-}());
-var WDOVerificationEndpoints = /** @class */ (function () {
-    function WDOVerificationEndpoints() {
-    }
-    WDOVerificationEndpoints.getStatus = {
-        path: "/api/identity/status",
-        e2eeScope: "NONE",
-        tokenName: "possession_universal",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.init = {
-        path: "/api/identity/init",
-        uriId: "/api/identity/init",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.cancel = {
-        path: "/api/identity/cleanup",
-        uriId: "/api/identity/cleanup",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.consentText = {
-        path: "/api/identity/consent/text",
-        tokenName: "possession_universal",
-        e2eeScope: "NONE",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.consentApprove = {
-        path: "/api/identity/consent/approve",
-        uriId: "/api/identity/consent/approve",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.documentScanSdkInit = {
-        path: "/api/identity/document/init-sdk",
-        uriId: "/api/identity/document/init-sdk",
-        e2eeScope: "ACTIVATION",
-        returnsData: true
-    };
-    // Legacy endpoint that required zip file upload
-    WDOVerificationEndpoints.submitDocuments = {
-        path: "/api/identity/document/submit",
-        tokenName: "possession_universal",
-        e2eeScope: "ACTIVATION",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.v2submitDocuments = {
-        path: "/api/v2/identity/document/submit",
-        tokenName: "possession_universal",
-        e2eeScope: "ACTIVATION",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.documentsStatus = {
-        path: "/api/identity/document/status",
-        tokenName: "possession_universal",
-        e2eeScope: "NONE",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.presenceCheckInit = {
-        path: "/api/identity/presence-check/init",
-        uriId: "/api/identity/presence-check/init",
-        e2eeScope: "ACTIVATION",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.presenceCheckSubmit = {
-        path: "/api/identity/presence-check/submit",
-        uriId: "/api/identity/presence-check/submit",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.resendOTP = {
-        path: "/api/identity/otp/resend",
-        uriId: "/api/identity/otp/resend",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.verifyOTP = {
-        path: "/api/identity/otp/verify",
-        e2eeScope: "ACTIVATION",
-        returnsData: true
-    };
-    return WDOVerificationEndpoints;
-}());
-
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-var WDOBaseApi = /** @class */ (function () {
-    function WDOBaseApi() {
-    }
-    // Configuration endpoints
-    WDOBaseApi.prototype.getConfiguration = function (processType) {
-        var requestObject = { processType: processType };
-        return this.callApi(requestObject, { path: "/api/configuration", e2eeScope: "APPLICATION", returnsData: true });
-    };
-    // Activation endpoints
-    WDOBaseApi.prototype.activationStart = function (credentials, processType) {
-        var requestObject = { identification: credentials, processType: processType };
-        return this.callApi(requestObject, WDOActivationEndpoints.start);
-    };
-    WDOBaseApi.prototype.activationCancel = function (processId) {
-        var requestObject = { processId: processId };
-        return this.callApi(requestObject, WDOActivationEndpoints.cancel);
-    };
-    WDOBaseApi.prototype.activationGetStatus = function (processId) {
-        var requestObject = { processId: processId };
-        return this.callApi(requestObject, WDOActivationEndpoints.getStatus);
-    };
-    WDOBaseApi.prototype.activationResendOTP = function (processId) {
-        var requestObject = { processId: processId };
-        return this.callApi(requestObject, WDOActivationEndpoints.resendOTP);
-    };
-    WDOBaseApi.prototype.activationGetOTP = function (processId, otpType) {
-        var requestObject = { processId: processId, otpType: otpType };
-        return this.callApi(requestObject, { path: "/api/onboarding/otp/detail", e2eeScope: "APPLICATION", returnsData: true });
-    };
-    // Verification endpoints
-    WDOBaseApi.prototype.verificationStatus = function () {
-        var requestObject = {};
-        return this.callApi(requestObject, WDOVerificationEndpoints.getStatus);
-    };
-    WDOBaseApi.prototype.verificationStart = function (processId) {
-        var requestObject = { processId: processId };
-        return this.callApi(requestObject, WDOVerificationEndpoints.init);
-    };
-    WDOBaseApi.prototype.verificationCleanup = function (processId) {
-        var requestObject = { processId: processId };
-        return this.callApi(requestObject, WDOVerificationEndpoints.cancel);
-    };
-    WDOBaseApi.prototype.verificationGetConsentText = function (processId) {
-        var requestObject = { processId: processId, consentType: "GDPR" }; // TODO: hardcoded type
-        return this.callApi(requestObject, WDOVerificationEndpoints.consentText);
-    };
-    WDOBaseApi.prototype.verificationResolveConsent = function (processId, approved) {
-        var requestObject = { processId: processId, approved: approved, consentType: "GDPR" }; // TODO: hardcoded type
-        return this.callApi(requestObject, WDOVerificationEndpoints.consentApprove);
-    };
-    WDOBaseApi.prototype.verificationInitScanSDK = function (processId, challenge) {
-        var requestObject = { processId: processId, attributes: { 'sdk-init-token': challenge } };
-        return this.callApi(requestObject, WDOVerificationEndpoints.documentScanSdkInit);
-    };
-    WDOBaseApi.prototype.verificationSubmitDocumentsV2 = function (processId, resubmit, documents) {
-        var requestObject = {
-            processId: processId,
-            resubmit: resubmit,
-            documents: documents
-        };
-        // TODO: there should be longer timeout!
-        return this.callApi(requestObject, WDOVerificationEndpoints.v2submitDocuments);
-    };
-    WDOBaseApi.prototype.verificationSubmitDocuments = function (processId, data, resubmit, documents) {
-        var requestObject = { processId: processId, data: data, resubmit: resubmit, documents: documents };
-        // TODO: there should be longer timeout!
-        return this.callApi(requestObject, WDOVerificationEndpoints.submitDocuments);
-    };
-    WDOBaseApi.prototype.verificationDocumentsStatus = function (processId) {
-        var requestObject = { processId: processId };
-        // TODO: longer timeout?
-        return this.callApi(requestObject, WDOVerificationEndpoints.documentsStatus);
-    };
-    WDOBaseApi.prototype.verificationPresenceCheckInit = function (processId) {
+    WDOApi.prototype.verificationPresenceCheckInit = function (processId) {
         var requestObject = { processId: processId };
         return this.callApi(requestObject, WDOVerificationEndpoints.presenceCheckInit);
     };
-    WDOBaseApi.prototype.verificationPresenceCheckSubmit = function (processId) {
+    WDOApi.prototype.verificationPresenceCheckSubmit = function (processId) {
         var requestObject = { processId: processId };
         return this.callApi(requestObject, WDOVerificationEndpoints.presenceCheckSubmit);
     };
-    WDOBaseApi.prototype.verificationResendOTP = function (processId) {
+    WDOApi.prototype.verificationResendOTP = function (processId) {
         var requestObject = { processId: processId };
         return this.callApi(requestObject, WDOVerificationEndpoints.resendOTP);
     };
-    WDOBaseApi.prototype.verifyOTP = function (processId, otp) {
+    WDOApi.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) {
+    WDOApi.prototype.verificationFinishActivation = function (processId, userIdentification) {
+        var requestObject = { processId: processId, identification: userIdentification };
+        return this.callApi(requestObject, WDOVerificationEndpoints.finishActivation);
+    };
+    WDOApi.prototype.callApi = function (requestObject, endpoint, authObject) {
+        if (authObject && !(authObject instanceof PowerAuthAuthentication)) {
+            throw new WDOError(exports.WDOErrorReason.invalidParameter, "The authObject parameter must be of type PowerAuthAuthentication.");
+        }
+        // set authentication to given authObject or to possession if endpoint is "signed"
+        var authentication = authObject || (endpoint.tokenName || endpoint.uriId ? PowerAuthAuthentication.possession() : undefined);
         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) {
+        this.constructEndpoint(endpoint), { requestObject: requestObject }, authentication).then(function (result) {
             if (result.responseObject) {
                 return result.responseObject;
             }
             else if (result.responseError) {
-                throw new WDOError("Server API error: ".concat(result.responseError.code, ", ").concat(result.responseError.message), result.responseError);
+                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("Failed to retrieve activation data");
+                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;
+            scope = 1;
         }
         else if (endpoint.e2eeScope === "APPLICATION") {
-            scope = WPNE2EEConfiguration.APPLICATION_SCOPE;
+            scope = 0;
         }
         else {
-            scope = WPNE2EEConfiguration.NOT_ENCRYPTED;
+            scope = 2;
         }
         if (endpoint.uriId) {
-            return WPNEndpoint.signed(endpoint.path, endpoint.uriId, undefined, scope);
+            return WDOPlatform.networkingFactory.signedEndpoint(endpoint.path, endpoint.uriId, undefined, scope);
         }
         else if (endpoint.tokenName) {
-            return WPNEndpoint.signedWithToken(endpoint.path, endpoint.tokenName, undefined, scope);
+            return WDOPlatform.networkingFactory.signedWithTokenEndpoint(endpoint.path, endpoint.tokenName, undefined, scope);
         }
         else {
-            return WPNEndpoint.unsigned(endpoint.path, undefined, scope);
+            return WDOPlatform.networkingFactory.unsignedEndpoint(endpoint.path, undefined, scope);
         }
     };
     return WDOApi;
-}(WDOBaseApi));
+}());
 
 /**
  * Copyright Wultra s.r.o.
@@ -703,109 +599,111 @@ var WDOApi = /** @class */ (function (_super) {
  *
  * 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 = {}));
+/* @internal */
+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 = {}));
+/* @internal */
+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";
+    /** Exchanging the temporary activation for the permanent one. */
+    WDOIdentityVerificationPhase["activationFinish"] = "ACTIVATION_FINISH";
+})(exports.WDOIdentityVerificationPhase || (exports.WDOIdentityVerificationPhase = {}));
+/* @internal */
+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 = {}));
+/* @internal */
+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 = {}));
+/* @internal */
+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 = {}));
 
 /**
- * Service that can activate PowerAuth instance by user weak credentials (like his email, phone number or client ID) + optional SMS OTP.
+ * Copyright Wultra s.r.o.
  *
- * 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 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.
  *
- * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
+ * SPDX-License-Identifier: Apache-2.0
  */
-var WDOActivationService = /** @class */ (function (_super) {
-    __extends(WDOActivationService, _super);
+/** Image of a document that can be sent to the backend for Identity Verification. */
+var WDODocumentFile = /** @class */ (function () {
     /**
-     * Creates service instance
+     * Image of a document that can be sent to the backend for Identity Verification.
      *
-     * @param powerauth Configured PowerAuth instance. This instance needs to be without valid activation.
-     * @param baseUrl Base URL of the Wultra Digital Onboarding server. Usually ending with `/enrollment-onboarding-server`.
-     */
-    function WDOActivationService(powerauth, baseUrl) {
-        var _this = _super.call(this) || this;
-        _this.api = new WDOApi(powerauth, baseUrl);
-        _this.powerauth = powerauth;
-        return _this;
-    }
-    /* @internal */
-    WDOActivationService.prototype.activatePowerAuth = function (identityAttributes, activationName) {
-        var activation = PowerAuthActivation.createWithIdentityAttributes(identityAttributes, activationName);
-        return this.powerauth.createActivation(activation);
-    };
-    /* @internal */
-    WDOActivationService.prototype.activatePowerAuthWithCode = function (activationCode, otp, activationName) {
-        var activation = PowerAuthActivation.createWithActivationCode(activationCode, activationName);
-        if (otp) {
-            activation.additionalActivationOtp = otp;
-        }
-        return this.powerauth.createActivation(activation);
-    };
-    /* @internal */
-    WDOActivationService.prototype.changeAcceptLanguageImpl = function (language) {
-        this.api.networking.acceptLanguage = language;
-    };
-    return WDOActivationService;
-}(WDOBaseActivationService));
-
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * The `WDOPowerAuthActivationState` enum defines all possible states of activation.
- * The state is a part of information received together with the rest
- * of the `WDOPowerAuthActivationStatus` object.
- */
-var WDOPowerAuthActivationState;
-(function (WDOPowerAuthActivationState) {
-    /**
-     * The activation is just created.
-     */
-    WDOPowerAuthActivationState["CREATED"] = "CREATED";
-    /**
-     * The activation is not completed yet on the server.
-     */
-    WDOPowerAuthActivationState["PENDING_COMMIT"] = "PENDING_COMMIT";
-    /**
-     * The shared secure context is valid and active.
-     */
-    WDOPowerAuthActivationState["ACTIVE"] = "ACTIVE";
-    /**
-     * The activation is blocked.
-     */
-    WDOPowerAuthActivationState["BLOCKED"] = "BLOCKED";
-    /**
-     * The activation doesn't exist anymore.
-     */
-    WDOPowerAuthActivationState["REMOVED"] = "REMOVED";
-    /**
-     * The activation is technically blocked. You cannot use it anymore
-     * for the signature calculations.
-     */
-    WDOPowerAuthActivationState["DEADLOCK"] = "DEADLOCK";
-})(WDOPowerAuthActivationState || (WDOPowerAuthActivationState = {}));
-
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-/** Image of a document that can be sent to the backend for Identity Verification. */
-var WDODocumentFile = /** @class */ (function () {
-    /**
-     * Image of a document that can be sent to the backend for Identity Verification.
-     *
-     * @param data Raw image data. Make sure that the data aren't too big, hundreds of kbs should be enough.
-     * @param type Type of the document.
-     * @param side The side of the document that the image captures.
-     * @param originalDocumentId Original document ID In case of a reupload. If you've previously uploaded this type and side and won't specify the previous ID, the image won't be overwritten.
-     * @param dataSignature Signature of the image data. Optional, use only when the scan SDK supports this. `undefined` by default.
+     * @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;
@@ -840,22 +738,6 @@ exports.WDODocumentType = void 0;
     /** 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) {
@@ -867,232 +749,27 @@ exports.WDODocumentSide = void 0;
     /** Back side of a document */
     WDODocumentSide["back"] = "back";
 })(exports.WDODocumentSide || (exports.WDODocumentSide = {}));
-
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-/** Status of the onboarding */
-var WDOOnboardingStatus;
-(function (WDOOnboardingStatus) {
-    /** Activation part of the process is in progress */
-    WDOOnboardingStatus["activationInProgress"] = "ACTIVATION_IN_PROGRESS";
-    /** Verification part of the process is in progress */
-    WDOOnboardingStatus["verificationInProgress"] = "VERIFICATION_IN_PROGRESS";
-    /** Onboarding process has failed */
-    WDOOnboardingStatus["failed"] = "FAILED";
-    /** Onboarding process is completed */
-    WDOOnboardingStatus["finished"] = "FINISHED";
-})(WDOOnboardingStatus || (WDOOnboardingStatus = {}));
-/** Status of the current identity verification */
-var WDOIdentityVerificationStatus;
-(function (WDOIdentityVerificationStatus) {
-    /** Identity verification is waiting for initialization */
-    WDOIdentityVerificationStatus["notInitialized"] = "NOT_INITIALIZED";
-    /** All submitted documents are waiting for verification */
-    WDOIdentityVerificationStatus["verificationPending"] = "VERIFICATION_PENDING";
-    /** Identity verification is in progress */
-    WDOIdentityVerificationStatus["inProgress"] = "IN_PROGRESS";
-    /** Identity verification was successfully completed */
-    WDOIdentityVerificationStatus["accepted"] = "ACCEPTED";
-    /** Identity verification has failed, an error occurred */
-    WDOIdentityVerificationStatus["failed"] = "FAILED";
-    /** Identity verification was rejected */
-    WDOIdentityVerificationStatus["rejected"] = "REJECTED";
-})(WDOIdentityVerificationStatus || (WDOIdentityVerificationStatus = {}));
-/** Phase of the current identity verification */
-var WDOIdentityVerificationPhase;
-(function (WDOIdentityVerificationPhase) {
-    /** Document upload is in progress */
-    WDOIdentityVerificationPhase["documentUpload"] = "DOCUMENT_UPLOAD";
-    /** Presence check is in progress */
-    WDOIdentityVerificationPhase["presenceCheck"] = "PRESENCE_CHECK";
-    /** Backend is verifying documents */
-    WDOIdentityVerificationPhase["clientEvaluation"] = "CLIENT_EVALUATION";
-    /** Document verification is in progress */
-    WDOIdentityVerificationPhase["documentVerification"] = "DOCUMENT_VERIFICATION";
-    /** Cross check on documents is in progress */
-    WDOIdentityVerificationPhase["documentVerificationFinal"] = "DOCUMENT_VERIFICATION_FINAL";
-    /** OTP verification needed */
-    WDOIdentityVerificationPhase["otp"] = "OTP_VERIFICATION";
-    /** Completed */
-    WDOIdentityVerificationPhase["completed"] = "COMPLETED";
-})(WDOIdentityVerificationPhase || (WDOIdentityVerificationPhase = {}));
-/** Types of available documents */
-var WDODocumentSubmitFileType;
-(function (WDODocumentSubmitFileType) {
-    /** National ID card */
-    WDODocumentSubmitFileType["idCard"] = "ID_CARD";
-    /** Passport */
-    WDODocumentSubmitFileType["passport"] = "PASSPORT";
-    /** Driving license */
-    WDODocumentSubmitFileType["driversLicense"] = "DRIVING_LICENSE";
-    /** Selfie photo */
-    WDODocumentSubmitFileType["selfiePhoto"] = "SELFIE_PHOTO";
-})(WDODocumentSubmitFileType || (WDODocumentSubmitFileType = {}));
-/** Side of the file */
-var WDODocumentSubmitFileSide;
-(function (WDODocumentSubmitFileSide) {
-    /** Front side of an document. Usually the one with the picture */
-    WDODocumentSubmitFileSide["front"] = "FRONT";
-    /** Back side of an document */
-    WDODocumentSubmitFileSide["back"] = "BACK";
-})(WDODocumentSubmitFileSide || (WDODocumentSubmitFileSide = {}));
-/** Status of the document */
-var WDODocumentStatus;
-(function (WDODocumentStatus) {
-    /** Document was accepted */
-    WDODocumentStatus["accepted"] = "ACCEPTED";
-    /** Document is being uploaded to the verification system by the backend */
-    WDODocumentStatus["uploadInProgress"] = "UPLOAD_IN_PROGRESS";
-    /** Document are being processed */
-    WDODocumentStatus["inProgress"] = "IN_PROGRESS";
-    /** Document is pending verification */
-    WDODocumentStatus["verificationPending"] = "VERIFICATION_PENDING";
-    /** Document is being verified */
-    WDODocumentStatus["verificationInProgress"] = "VERIFICATION_IN_PROGRESS";
-    /** Document was rejected */
-    WDODocumentStatus["rejected"] = "REJECTED";
-    /** Verification of the document failed */
-    WDODocumentStatus["failed"] = "FAILED";
-})(WDODocumentStatus || (WDODocumentStatus = {}));
-/** Converts WDODocumentType to DocumentSubmitFileType */
-function WDOCreateDocumentSubmitFileType(type) {
+/* @internal */
+function WDODocumentTypeToSubmitType(type) {
     switch (type) {
         case exports.WDODocumentType.idCard:
-            return WDODocumentSubmitFileType.idCard;
+            return exports.WDODocumentSubmitFileType.idCard;
         case exports.WDODocumentType.passport:
-            return WDODocumentSubmitFileType.passport;
+            return exports.WDODocumentSubmitFileType.passport;
         case exports.WDODocumentType.driversLicense:
-            return WDODocumentSubmitFileType.driversLicense;
+            return exports.WDODocumentSubmitFileType.driversLicense;
     }
 }
-/** Converts WDODocumentSide to DocumentSubmitFileSide */
+/* @internal */
 function WDOCreateDocumentSubmitFileSide(side) {
     switch (side) {
         case exports.WDODocumentSide.front:
-            return WDODocumentSubmitFileSide.front;
+            return exports.WDODocumentSubmitFileSide.front;
         case exports.WDODocumentSide.back:
-            return WDODocumentSubmitFileSide.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
- */
-/** Types of the verification state */
-exports.WDOVerificationStateType = void 0;
-(function (WDOVerificationStateType) {
-    /**
-     * Show the verification introduction screen where the user can start the activation.
-     *
-     * The next step should be calling the `consentGet()`.
-     */
-    WDOVerificationStateType["intro"] = "intro";
-    /**
-     * Show approve/cancel user consent.
-     *
-     * The content of the text depends on the server configuration and might be plain text or HTML.
-     *
-     * The next step should be calling the `consentApprove`.
-     */
-    WDOVerificationStateType["consent"] = "consent";
-    /**
-     * Show document selection to the user. Which documents are available and how many
-     * can the user select is up to your backend configuration.
-     *
-     * The next step should be calling the `documentsSetSelectedTypes`.
-     */
-    WDOVerificationStateType["documentsToScanSelect"] = "documentsToScanSelect";
-    /**
-     * User should scan documents - display UI for the user to scan all necessary documents.
-     *
-     * The next step should be calling the `documentsSubmit`.
-     */
-    WDOVerificationStateType["scanDocument"] = "scanDocument";
-    /**
-     * The system is processing data - show loading with text hint from provided `WDOStatusCheckReason`.
-     *
-     * The next step should be calling the `status`.
-     */
-    WDOVerificationStateType["processing"] = "processing";
-    /**
-     * The user should be presented with a presence check.
-     * Presence check is handled by third-party SDK based on the project setup.
-     *
-     * The next step should be calling the `presenceCheckInit` to start the check and `presenceCheckSubmit` to
-     * mark it finished.  Note that these methods won't change the status and it's up to the app to handle the process of the presence check.
-     */
-    WDOVerificationStateType["presenceCheck"] = "presenceCheck";
-    /**
-     * Show enter OTP screen with resend button.
-     *
-     * The next step should be calling the `verifyOTP` with user-entered OTP.
-     * The OTP is usually SMS or email.
-     */
-    WDOVerificationStateType["otp"] = "otp";
-    /**
-     * Verification failed and can be restarted
-     *
-     * The next step should be calling the `restartVerification` or `cancelWholeProcess` based on
-     * the user's decision if he wants to try it again or cancel the process.
-     */
-    WDOVerificationStateType["failed"] = "failed";
-    /**
-     * Verification is canceled and the user needs to start again with a new PowerAuth activation.
-     *
-     * The next step should be calling the `PowerAuth.removeActivationLocal()` and starting activation from scratch.
-     */
-    WDOVerificationStateType["endState"] = "endState";
-    /**
-     * Verification was successfully ended. Continue into your app flow.
-     */
-    WDOVerificationStateType["success"] = "success";
-})(exports.WDOVerificationStateType || (exports.WDOVerificationStateType = {}));
-/** The reason why the process ended in a non-recoverable state. */
-exports.WDOEndStateReason = void 0;
-(function (WDOEndStateReason) {
-    /**
-     * The verification was rejected by the system
-     *
-     * eg: Fake information, fraud detection, or user is trying repeatedly in a short time.
-     * The real reason is not presented to the user and is only audited on the server.
-     */
-    WDOEndStateReason["rejected"] = "rejected";
-    /**
-     * The limit of repeat tries was reached. There is a fixed number of tries that the user can reach
-     * before the system stops the process.
-     */
-    WDOEndStateReason["limitReached"] = "limitReached";
-    /** An unknown reason. */
-    WDOEndStateReason["other"] = "other";
-})(exports.WDOEndStateReason || (exports.WDOEndStateReason = {}));
-/**
- * The reason for what we are waiting for. For example, we can wait for documents to be OCRed and matched against the database.
- * Use these values for better loading texts to tell the user what is happening - some tasks may take some time
- * and it would be frustrating to just show a generic loading indicator.
- */
-exports.WDOStatusCheckReason = void 0;
-(function (WDOStatusCheckReason) {
-    WDOStatusCheckReason["unknown"] = "unknown";
-    WDOStatusCheckReason["documentUpload"] = "documentUpload";
-    WDOStatusCheckReason["documentVerification"] = "documentVerification";
-    WDOStatusCheckReason["documentAccepted"] = "documentAccepted";
-    WDOStatusCheckReason["documentsCrossVerification"] = "documentsCrossVerification";
-    WDOStatusCheckReason["clientVerification"] = "clientVerification";
-    WDOStatusCheckReason["clientAccepted"] = "clientAccepted";
-    WDOStatusCheckReason["verifyingPresence"] = "verifyingPresence";
-})(exports.WDOStatusCheckReason || (exports.WDOStatusCheckReason = {}));
-
 /**
  * Copyright Wultra s.r.o.
  *
@@ -1126,10 +803,27 @@ var WDOVerificationScanProcess = /** @class */ (function () {
         }, new Map());
         groups.forEach(function (docs, type) {
             var _a;
-            // TODO: type mismatch?
-            (_a = _this.documents.find(function (d) { return d.type === type; })) === null || _a === void 0 ? void 0 : _a.processServerData(docs);
+            (_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. */
@@ -1154,43 +848,871 @@ var WDOScannedDocument = /** @class */ (function () {
                     return exports.UploadState.rejected;
                 }
             }
-            return exports.UploadState.accepted;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(WDOScannedDocument.prototype, "sides", {
-        /** Sides of the document that were uploaded on the server. */
-        get: function () { return this._sides; },
-        enumerable: false,
-        configurable: true
-    });
-    /* @internal */
-    WDOScannedDocument.prototype.processServerData = function (documents) {
-        this._sides = documents.map(function (doc) { var _a, _b; return new Side(doc.side == WDODocumentSubmitFileSide.front ? exports.WDODocumentSide.front : exports.WDODocumentSide.back, doc.id, ((_b = (_a = doc.errors) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0 ? exports.UploadState.rejected : exports.UploadState.accepted); });
+            return 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 () {
+    /**
+     * 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 WDOBaseVerificationService(powerauth, baseUrl) {
+        // --
+        /* @internal */
+        this.lastStatus = undefined;
+        this.powerauth = powerauth;
+        this.api = new WDOApi(powerauth, baseUrl);
+    }
+    /** Checks if verification is required based on PowerAuth activation status */
+    WDOBaseVerificationService.isVerificationRequiredInternal = 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 */
+    WDOBaseVerificationService.prototype.cacheKey = function () { return "wdocp_".concat(this.powerauth.instanceId); };
+    /* @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*/, WDOPlatform.cache.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*/, WDOPlatform.cache.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.api.networking.acceptLanguage = 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;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 18, , 19]);
+                        return [4 /*yield*/, this.api.verificationStatus()];
+                    case 1:
+                        response = _d.sent();
+                        WDOLogger.info("Verification status successfully retrieved.");
+                        WDOLogger.debug("Verification status: ".concat(JSON.stringify(response)));
+                        if (response.consentRequired == undefined) {
+                            WDOLogger.debug("Consent required flag not present in the response, assuming false");
+                            response.consentRequired = false;
+                        }
+                        _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:
+                        _d.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];
+                            case WDONextStep.finishActivation: return [3 /*break*/, 16];
+                        }
+                        return [3 /*break*/, 17];
+                    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 = _d.sent();
+                        WDOLogger.debug("Documents status: ".concat(JSON.stringify(docsResponse)));
+                        documents = docsResponse.documents;
+                        return [4 /*yield*/, this.getCachedProcess()];
+                    case 9:
+                        cachedProcess = _d.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: (_c = vf.statusCheckReason) !== null && _c !== void 0 ? _c : 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 [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.finishActivation })];
+                    case 17: return [3 /*break*/, 19];
+                    case 18:
+                        error_1 = _d.sent();
+                        WDOLogger.error("Error fetching verification status: ".concat(JSON.stringify(error_1)));
+                        this.lastStatus = undefined;
+                        throw this.processError(error_1);
+                    case 19: 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"));
+                            }
+                        }
+                }
+            });
+        });
+    };
+    /**
+     * Finishes verification by creating a new PowerAuth activation on given `newPowerAuthInstance`.
+     *
+     * Needs to be called when "activationFinish" next step is returned from the `status()` call.
+     *
+     * The method verifies that the provided `password` is the same as used in the original activation
+     * (if `validatePassword` is set to `true`), then it calls the server API to finish
+     * the verification and obtain the activation code for the new activation. Finally, it creates
+     * a new activation on `newPowerAuthInstance` using the obtained activation code and persists it
+     * with the provided `newPassword`.
+     *
+     * After successful completion, the original PowerAuth instance becomes invalid (`REMOVED` state) and cannot be used anymore.
+     *
+     * @param newPowerAuthInstance PowerAuth instance where to create new activation. This instance must not have an existing activation.
+     * @param newActivationName Name of the new activation to be created on `newPowerAuthInstance`.
+     * @param newPassword Password to protect the new activation. In case `validatePassword` is `true`, this password must match the password of the original activation and must be reusable (not destroyed on use).
+     * @param validatePassword If set to `true`, the method verifies that the provided `newPassword` matches the password of the original activation.
+     * @param userIdentification Optional user identification object to be sent to the server during the finish activation process.
+     */
+    WDOBaseVerificationService.prototype.finishActivation = function (newPowerAuthInstance, newActivationName, newPassword, validatePassword, userIdentification) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, response, activation, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, , 12, 14]);
+                        pid = this.verifyHasActiveProcess();
+                        if (!validatePassword) return [3 /*break*/, 2];
+                        // password must be reusable
+                        if (newPassword.destroyOnUse) { // TODO: ok? maybe make this property public in PowerAuthPassword?
+                            throw new WDOError(exports.WDOErrorReason.invalidParameter, "The provided PowerAuthPassword is configured to be destroyed on use, which is not supported in finishActivation with validatePassword=true. Please provide a reusable PowerAuthPassword instance. (with destroyOnUse=false)");
+                        }
+                        // validate password against original activation
+                        return [4 /*yield*/, this.powerauth.validatePassword(newPassword)];
+                    case 1:
+                        // validate password against original activation
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.handleError(this.api.verificationFinishActivation(pid, userIdentification))];
+                    case 3:
+                        response = _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 7, , 11]);
+                        activation = WDOPlatform.powerAuthFactory.activationWithActivationCode(response.activationCode, newActivationName, undefined);
+                        return [4 /*yield*/, newPowerAuthInstance.createActivation(activation)];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, newPowerAuthInstance.persistActivation(WDOPlatform.powerAuthFactory.authenticationWithPassword(newPassword))];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 11];
+                    case 7:
+                        e_1 = _a.sent();
+                        return [4 /*yield*/, newPowerAuthInstance.canStartActivation()];
+                    case 8:
+                        if (!((_a.sent()) == false)) return [3 /*break*/, 10];
+                        return [4 /*yield*/, newPowerAuthInstance.removeActivationLocal()];
+                    case 9:
+                        _a.sent();
+                        _a.label = 10;
+                    case 10: throw e_1; // rethrow
+                    case 11: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.success })];
+                    case 12: return [4 /*yield*/, newPassword.clear()]; // destroy the password after use
+                    case 13:
+                        _a.sent(); // destroy the password after use
+                        return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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.powerauth.fetchActivationStatus()];
+                    case 2:
+                        status_1 = _c.sent();
+                        if (status_1.state !== "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;
+            }
+        }
+        else if (phase === exports.WDOIdentityVerificationPhase.activationFinish) {
+            // TODO: handle status?
+            nextStep = WDONextStep.finishActivation;
+        }
+        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 WDOScannedDocument;
+    return WDOVerificationStatus;
 }());
-/** 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;
+/* @internal */
+var WDONextStep;
+(function (WDONextStep) {
+    WDONextStep["intro"] = "intro";
+    WDONextStep["documentScan"] = "documentScan";
+    WDONextStep["statusCheck"] = "statusCheck";
+    WDONextStep["presenceCheck"] = "presenceCheck";
+    WDONextStep["otp"] = "otp";
+    WDONextStep["finishActivation"] = "finishActivation";
+    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";
     }
-    return Side;
-}());
+    WDOLogger.debug("Unknown document status: ".concat(document.status, " for document ID: ").concat(document.id));
+    return "error"; // fallback
+}
 
 /**
  * Copyright Wultra s.r.o.
@@ -1200,410 +1722,314 @@ var Side = /** @class */ (function () {
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * Service that can verify previously activated PowerAuth instance.
- *
- * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
- * This can be confirmed in the `WDOVerificationService.isVerificationRequired` which will be `true`.
- *
- * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
- */
-var WDOBaseVerificationService = /** @class */ (function () {
-    function WDOBaseVerificationService() {
-        /* @internal */
-        this.lastStatus = undefined;
-        /* @internal */
-        this.cachedProcess = undefined; // TODO: persistence?
+
+
+var WDOCordovaCache = /** @class */ (function () {
+    function WDOCordovaCache() {
     }
-    // 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);
+    WDOCordovaCache.prototype.set = function (key, value) {
+        if (value) {
+            return PowerAuthStorageUtils.setString(key, value, PowerAuthStorageType.SECURE);
+        }
+        else {
+            return PowerAuthStorageUtils.remove(key, PowerAuthStorageType.SECURE).then(function () { });
+        }
     };
-    Object.defineProperty(WDOBaseVerificationService.prototype, "otpResendPeriodSeconds", {
-        /** Time in seconds that user needs to wait between OTP resend calls */
-        get: function () {
-            var _a, _b;
-            return (_b = (_a = this.lastStatus) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.otpResendPeriodSeconds;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Status of the verification.
-     */
-    WDOBaseVerificationService.prototype.status = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, vf, _a, docsResponse, documents, cachedProcess, error_1;
-            var _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _c.trys.push([0, 12, , 13]);
-                        return [4 /*yield*/, this.api.verificationStatus()];
-                    case 1:
-                        response = _c.sent();
-                        WDOLogger.info("Verification status successfully retrieved.");
-                        WDOLogger.debug("Verification status: ".concat(JSON.stringify(response)));
-                        switch (response.identityVerificationStatus) {
-                            case WDOIdentityVerificationStatus.failed:
-                            case WDOIdentityVerificationStatus.rejected:
-                            case WDOIdentityVerificationStatus.notInitialized:
-                            case WDOIdentityVerificationStatus.accepted:
-                                WDOLogger.debug("Status ".concat(response.identityVerificationStatus, " - clearing cache"));
-                                this.cachedProcess = undefined;
-                                break;
-                        }
-                        this.lastStatus = response;
-                        vf = new WDOVerificationStatus(response);
-                        WDOLogger.info("Verification next step: ".concat(vf.description()));
-                        _a = vf.nextStep;
-                        switch (_a) {
-                            case WDONextStep.intro: return [3 /*break*/, 2];
-                            case WDONextStep.documentScan: return [3 /*break*/, 3];
-                            case WDONextStep.presenceCheck: return [3 /*break*/, 5];
-                            case WDONextStep.otp: return [3 /*break*/, 6];
-                            case WDONextStep.statusCheck: return [3 /*break*/, 7];
-                            case WDONextStep.failed: return [3 /*break*/, 8];
-                            case WDONextStep.rejected: return [3 /*break*/, 9];
-                            case WDONextStep.success: return [3 /*break*/, 10];
-                        }
-                        return [3 /*break*/, 11];
-                    case 2: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.intro })];
-                    case 3:
-                        WDOLogger.debug("Verifying documents status");
-                        return [4 /*yield*/, this.api.verificationDocumentsStatus(response.processId)];
-                    case 4:
-                        docsResponse = _c.sent();
-                        WDOLogger.debug("Documents status: ".concat(JSON.stringify(docsResponse)));
-                        documents = docsResponse.documents;
-                        cachedProcess = this.cachedProcess;
-                        if (cachedProcess) {
-                            cachedProcess.feedServerData(docsResponse.documents);
-                            if (documents.some(function (d) { return documentAction(d) === "error"; }) || documents.some(function (d) { return d.errors != undefined && d.errors.length > 0; })) {
-                                WDOLogger.debug("At least one document in error state: ".concat(documents.some(function (d) { return documentAction(d) === "error"; }), ", ").concat(documents.some(function (d) { return d.errors != undefined && d.errors.length > 0; })));
-                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.scanDocument, process: cachedProcess })];
-                            }
-                            else if (documents.every(function (d) { return documentAction(d) === "proceed"; })) {
-                                WDOLogger.debug("All documents accepted, proceeding");
-                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.scanDocument, process: cachedProcess })];
-                            }
-                            else if (documents.some(function (d) { return documentAction(d) === "wait"; })) {
-                                WDOLogger.debug("At least one document still in progress, moving to processing");
-                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.documentVerification })];
-                            }
-                            else if (documents.length == 0) {
-                                WDOLogger.debug("No documents scanned, scan documents...");
-                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.scanDocument, process: cachedProcess })];
-                            }
-                            else {
-                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.failed })];
-                            }
-                        }
-                        else {
-                            if (documents.length == 0) {
-                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.documentsToScanSelect })];
-                            }
-                            else {
-                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.failed })];
-                            }
-                        }
-                    case 5: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.presenceCheck })];
-                    case 6: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.otp })];
-                    case 7: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: (_b = vf.statusCheckReason) !== null && _b !== void 0 ? _b : exports.WDOStatusCheckReason.unknown })];
-                    case 8: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.failed })];
-                    case 9: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.endState, reason: exports.WDOEndStateReason.rejected })];
-                    case 10: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.success })];
-                    case 11: return [3 /*break*/, 13];
-                    case 12:
-                        error_1 = _c.sent();
-                        WDOLogger.error("Error fetching verification status: ".concat(JSON.stringify(error_1)));
-                        this.lastStatus = undefined;
-                        throw this.processError(error_1);
-                    case 13: return [2 /*return*/];
-                }
-            });
-        });
+    WDOCordovaCache.prototype.get = function (key) {
+        return PowerAuthStorageUtils.getString(key, PowerAuthStorageType.SECURE);
     };
-    /**
-     * Returns consent text for user to approve. The content of the text depends on the server configuration and might be plain text or HTML.
-     *
-     * Consent text explains how the service will handle his document photos or selfie scans.
-     */
-    WDOBaseVerificationService.prototype.consentGet = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid, response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.handleError(this.api.verificationGetConsentText(pid))];
-                    case 1:
-                        response = _a.sent();
-                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.consent, body: response.consentText })];
-                }
-            });
-        });
+    WDOCordovaCache.prototype.has = function (key) {
+        return PowerAuthStorageUtils.exists(key, PowerAuthStorageType.SECURE);
     };
-    /**
-     * Approves the consent for this process and starts the activation.
-     */
-    WDOBaseVerificationService.prototype.consentApprove = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.handleError(this.api.verificationResolveConsent(pid, true))];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.handleError(this.api.verificationStart(pid))];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.documentsToScanSelect })];
-                }
-            });
-        });
+    return WDOCordovaCache;
+}());
+var WDONetworkingFactoryCordova = /** @class */ (function () {
+    function WDONetworkingFactoryCordova() {
+    }
+    WDONetworkingFactoryCordova.prototype.signedEndpoint = function (path, uriId, responseConfig, e2eeConfig) {
+        return WPNEndpoint.signed(path, uriId, responseConfig, e2eeConfig);
     };
-    /**
-     * Get the token for the document scanning SDK, when required.
-     *
-     * This is needed for example for ZenID or BlinkID provider.
-     *
-     * @param challenge Optional challenge provided by the scanning SDK.
-     */
-    WDOBaseVerificationService.prototype.documentsInitSDK = function (challenge) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid, response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.handleError(this.api.verificationInitScanSDK(pid, challenge !== null && challenge !== void 0 ? challenge : "-"))]; // TODO: is "-" acceptable?
-                    case 1:
-                        response = _a.sent() // TODO: is "-" acceptable?
-                        ;
-                        return [2 /*return*/, response];
-                }
-            });
-        });
+    WDONetworkingFactoryCordova.prototype.signedWithTokenEndpoint = function (path, tokenName, responseConfig, e2eeConfig) {
+        return WPNEndpoint.signedWithToken(path, tokenName, responseConfig, e2eeConfig);
     };
-    /**
-     * Set which documents will be scanned.
-     *
-     * Note that this needs to be in sync what server expects based on the configuration.
-     *
-     * @param types Types of documents to scan.
-     */
-    WDOBaseVerificationService.prototype.documentsSetSelectedTypes = function (types) {
-        return __awaiter(this, void 0, void 0, function () {
-            var process;
-            return __generator(this, function (_a) {
-                WDOLogger.debug("Submitting selected document types: ".concat(types));
-                process = new WDOVerificationScanProcess(types);
-                this.cachedProcess = process;
-                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.scanDocument, process: process })];
-            });
-        });
+    WDONetworkingFactoryCordova.prototype.unsignedEndpoint = function (path, responseConfig, e2eeConfig) {
+        return WPNEndpoint.unsigned(path, responseConfig, e2eeConfig);
+    };
+    WDONetworkingFactoryCordova.prototype.networking = function (powerAuth, baseUrl) {
+        return new WPNNetworking(powerAuth, baseUrl);
+    };
+    return WDONetworkingFactoryCordova;
+}());
+var WDOPowerAuthFactoryCordova = /** @class */ (function () {
+    function WDOPowerAuthFactoryCordova() {
+    }
+    WDOPowerAuthFactoryCordova.prototype.activationWithActivationCode = function (activationCode, activationName, otp) {
+        var activation = PowerAuthActivation.createWithActivationCode(activationCode, activationName);
+        if (otp) {
+            activation.additionalActivationOtp = otp;
+        }
+        return activation;
+    };
+    WDOPowerAuthFactoryCordova.prototype.activationWithIdentityAttributes = function (identityAttributes, activationName) {
+        return PowerAuthActivation.createWithIdentityAttributes(identityAttributes, activationName);
+    };
+    WDOPowerAuthFactoryCordova.prototype.authenticationWithPassword = function (password) {
+        return PowerAuthAuthentication.password(password);
     };
+    return WDOPowerAuthFactoryCordova;
+}());
+
+/**
+ * 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 () {
+    // PUBLIC API
     /**
-     * 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.
+     * Creates service instance
      *
-     * @param files Document files to upload.
+     * @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`.
      */
-    WDOBaseVerificationService.prototype.documentsSubmit = function (files) {
+    function WDOBaseActivationService(powerauth, baseUrl) {
+        this.api = new WDOApi(powerauth, baseUrl);
+        this.powerauth = powerauth;
+    }
+    Object.defineProperty(WDOBaseActivationService.prototype, "cacheKey", {
+        /* @internal  */
+        get: function () { return "wdopd_".concat(this.powerauth.instanceId); },
+        enumerable: false,
+        configurable: true
+    });
+    /* @internal  */
+    WDOBaseActivationService.prototype.setCachedProcessData = function (data) {
         return __awaiter(this, void 0, void 0, function () {
-            var pid, resubmit, submitFiles;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        pid = this.verifyHasActiveProcess();
-                        resubmit = files.some(function (f) { return f.originalDocumentId != undefined; });
-                        submitFiles = files.map(function (f) {
-                            return {
-                                filename: "".concat(f.type.toLowerCase(), "_").concat(f.side.toLowerCase(), ".jpg"), // TODO: OK?
-                                type: WDOCreateDocumentSubmitFileType(f.type),
-                                side: WDOCreateDocumentSubmitFileSide(f.side),
-                                originalDocumentId: f.originalDocumentId,
-                                data: f.data
-                            };
-                        });
-                        return [4 /*yield*/, this.handleError(this.api.verificationSubmitDocumentsV2(pid, resubmit, submitFiles))];
+                    case 0: return [4 /*yield*/, WDOPlatform.cache.set(this.cacheKey, JSON.stringify(data))];
                     case 1:
                         _a.sent();
-                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.documentUpload })];
+                        return [2 /*return*/];
                 }
             });
         });
     };
-    /**
-     * @internal
-     * Upload document files to the server. The order of the documents is up to you.
-     * Make sure that uploaded document are reasonable size so you're not uploading large files.
-     *
-     * If you're uploading the same document file again, you need to include the `originalDocumentId` otherwise it will be rejected by the server.
-     *
-     * @param files Document files to upload.
-     */
-    WDOBaseVerificationService.prototype.documentsSubmitDemo = function (files, zipFolderNameDemo, base64zipDemo) {
+    /* @internal  */
+    WDOBaseActivationService.prototype.getCachedProcessData = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var pid, resubmit, submitFiles;
+            var data;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        pid = this.verifyHasActiveProcess();
-                        resubmit = files.some(function (f) { return f.originalDocumentId != undefined; });
-                        submitFiles = files.map(function (f) {
-                            return {
-                                filename: "".concat(zipFolderNameDemo, "/").concat(f.type.toLowerCase(), "_").concat(f.side.toLowerCase(), ".jpg"),
-                                type: WDOCreateDocumentSubmitFileType(f.type),
-                                side: WDOCreateDocumentSubmitFileSide(f.side),
-                                originalDocumentId: f.originalDocumentId
-                            };
-                        });
-                        return [4 /*yield*/, this.handleError(this.api.verificationSubmitDocuments(pid, base64zipDemo, resubmit, submitFiles))];
+                    case 0: return [4 /*yield*/, WDOPlatform.cache.get(this.cacheKey)];
                     case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.documentUpload })];
+                        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];
+            }
+        }); });
+    };
     /**
-     * Initiates the presence check. This returns attributes that are needed to start the 3rd party SDK (if needed).
+     * 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()` after the app is launched is recommended.
      */
-    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)];
-                }
-            });
-        });
+    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())];
+            }
+        }); });
     };
     /**
-     * Call when presence check was finished in the 3rd party SDK.
+     * 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.presenceCheckSubmit = function () {
+    WDOBaseActivationService.prototype.changeAcceptLanguage = function (language) {
+        this.api.networking.acceptLanguage = language;
+    };
+    /**
+     * Retrieves status of the onboarding activation.
+     *
+     * @return Promise resolved with onboarding status.
+     */
+    WDOBaseActivationService.prototype.status = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var pid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var _a, _b, _c, pid, result;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.handleError(this.api.verificationPresenceCheckSubmit(pid))];
+                        _b = (_a = WDOLogger).debug;
+                        _c = "Getting activation status for processId=".concat;
+                        return [4 /*yield*/, this.processId()];
                     case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.verifyingPresence })];
+                        _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];
                 }
             });
         });
     };
     /**
-     * Verification restart. When sucessfully called, intro screen should be presented.
+     * 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.
      */
-    WDOBaseVerificationService.prototype.restartVerification = function () {
+    WDOBaseActivationService.prototype.start = function (credentials, processType) {
         return __awaiter(this, void 0, void 0, function () {
-            var pid;
+            var result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.handleError(this.api.verificationCleanup(pid))];
+                        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();
-                        this.cachedProcess = undefined;
-                        WDOLogger.info("Verification process restarted.");
-                        return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.intro })];
+                        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 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.
+     * 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.
      */
-    WDOBaseVerificationService.prototype.cancelWholeProcess = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+    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:
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.handleError(this.api.verificationCleanup(pid))];
+                        _b = (_a = WDOLogger).debug;
+                        _c = "Canceling activation for processId=".concat;
+                        return [4 /*yield*/, this.processId()];
                     case 1:
-                        _a.sent();
-                        this.cachedProcess = undefined;
-                        WDOLogger.info("Verification process canceled.");
-                        return [2 /*return*/];
+                        _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*/];
                 }
             });
         });
     };
-    /**
-     * 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) {
+    /** Clear the stored data (without networking call). */
+    WDOBaseActivationService.prototype.clear = 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.verifyOTP(pid, otp))];
+                    case 0: return [4 /*yield*/, this.setCachedProcessData(undefined)];
                     case 1:
-                        response = _a.sent();
-                        if (response.verified) {
-                            WDOLogger.info("OTP verified successfully.");
-                            return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: exports.WDOStatusCheckReason.unknown })];
-                        }
-                        else {
-                            if (response.remainingAttempts > 0 && response.expired == false) {
-                                WDOLogger.error("OTP verification failed, remaining attempts: ".concat(response.remainingAttempts));
-                                return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.otp, remainingAttempts: response.remainingAttempts })];
-                            }
-                            else {
-                                WDOLogger.error("OTP verification failed, no remaining attempts or OTP expired");
-                                throw this.processError(new WDOError("OTP verification failed, no remaining attempts or OTP expired"));
-                            }
-                        }
+                        _a.sent();
+                        return [2 /*return*/];
                 }
             });
         });
     };
     /**
-     * Request OTP resend.
+     * OTP resend request.
      *
-     * Since SMS or emails can fail to deliver, use this to send the OTP again.
+     * 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".
+     * There is a server-side rate limit applied to this operation to prevent abuse; it is good practice to disable the button temporarily while the OTP is being sent.
      */
-    WDOBaseVerificationService.prototype.resendOTP = function () {
+    WDOBaseActivationService.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))];
+                        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*/];
                 }
@@ -1616,320 +2042,118 @@ var WDOBaseVerificationService = /** @class */ (function () {
      *
      * 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 () {
+    WDOBaseActivationService.prototype.getOTP = function () {
         return __awaiter(this, void 0, void 0, function () {
             var pid;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         WDOLogger.debug("Activation: getting OTP from server (only for testing purposes)");
-                        pid = this.verifyHasActiveProcess();
-                        return [4 /*yield*/, this.api.activationGetOTP(pid, "USER_VERIFICATION")];
-                    case 1: return [2 /*return*/, (_a.sent()).otpCode];
+                        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];
                 }
             });
         });
     };
-    // PRIVATE METHODS
-    /* @internal */
-    WDOBaseVerificationService.prototype.verifyHasActiveProcess = function () {
-        var _a;
-        var pid = (_a = this.lastStatus) === null || _a === void 0 ? void 0 : _a.processId;
-        if (!pid) {
-            WDOLogger.error("Process id not available - did you start the verification process and fetched the status?");
-            throw new WDOError("Process id not available - did you start the verification process and fetched the status?");
-        }
-        return pid;
-    };
-    /* @internal */
-    WDOBaseVerificationService.prototype.processSuccess = function (result) {
-        var _a;
-        if (result.type !== undefined) {
-            (_a = this.listener) === null || _a === void 0 ? void 0 : _a.verificationStatusChanged(this, result);
-        }
-        return result;
-    };
-    /* @internal */
-    WDOBaseVerificationService.prototype.handleError = function (promise) {
-        var _this = this;
-        return promise.catch(function (error) {
-            throw _this.processError(error);
+    /**
+     * 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, activation, identityAttributes, activation, 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");
+                        activation = WDOPlatform.powerAuthFactory.activationWithActivationCode(code, activationName, otp);
+                        return [4 /*yield*/, this.powerauth.createActivation(activation)];
+                    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" };
+                        activation = WDOPlatform.powerAuthFactory.activationWithIdentityAttributes(identityAttributes, activationName);
+                        return [4 /*yield*/, this.powerauth.createActivation(activation)];
+                    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 */
-    WDOBaseVerificationService.prototype.processError = function (error) {
+    WDOBaseActivationService.prototype.verifyCanStartActivation = function () {
         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;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.powerauth.canStartActivation()];
                     case 1:
-                        _c.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.fetchActivationStatus()];
+                        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:
-                        status_1 = _c.sent();
-                        if (status_1.state !== WDOPowerAuthActivationState.ACTIVE) {
-                            WDOLogger.error("PowerAuth status is not active (status".concat(status_1.state, ") - notifying the delegate and returning and error."));
-                            (_b = this.listener) === null || _b === void 0 ? void 0 : _b.powerAuthActivationStatusChanged(this, status_1);
-                            return [2 /*return*/, new WDOError("PowerAuth activation is not active anymore")];
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _c.sent();
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/, error];
+                        _a.sent();
+                        throw new WDOError(exports.WDOErrorReason.powerauthAlreadyActivated, "PowerAuth is already activated");
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
-    return WDOBaseVerificationService;
-}());
-// INTERNAL CLASSES
-/**
-  @internal
-  Internal status that works as a translation layer between server API and SDK API
-*/
-var WDOVerificationStatus = /** @class */ (function () {
-    /** Translation from server status to phone status. */
-    function WDOVerificationStatus(serverResponse) {
-        var phase = serverResponse.identityVerificationPhase;
-        var status = serverResponse.identityVerificationStatus;
-        var nextStep = undefined;
-        var statusCheckReason = undefined;
-        // UNDEFINED PHASE
-        if (phase == undefined) {
-            switch (status) {
-                case WDOIdentityVerificationStatus.notInitialized:
-                    nextStep = WDONextStep.intro;
-                    break;
-                case WDOIdentityVerificationStatus.failed:
-                    nextStep = WDONextStep.failed;
-                    break;
-            }
-        }
-        // DOCUMENT UPLOAD PHASE
-        else if (phase === WDOIdentityVerificationPhase.documentUpload) {
-            switch (status) {
-                case WDOIdentityVerificationStatus.inProgress:
-                    nextStep = WDONextStep.documentScan;
-                    break;
-                case WDOIdentityVerificationStatus.verificationPending:
-                    nextStep = WDONextStep.statusCheck;
-                    statusCheckReason = exports.WDOStatusCheckReason.documentVerification;
-                    break;
-                case WDOIdentityVerificationStatus.failed:
-                    nextStep = WDONextStep.failed;
-                    break;
-            }
-        }
-        // DOCUMENT VERIFICATION PHASE
-        else if (phase === WDOIdentityVerificationPhase.documentVerification) {
-            switch (status) {
-                case WDOIdentityVerificationStatus.accepted:
-                    nextStep = WDONextStep.statusCheck;
-                    statusCheckReason = exports.WDOStatusCheckReason.documentAccepted;
-                    break;
-                case WDOIdentityVerificationStatus.inProgress:
-                    nextStep = WDONextStep.statusCheck;
-                    statusCheckReason = exports.WDOStatusCheckReason.documentVerification;
-                    break;
-                case WDOIdentityVerificationStatus.failed:
-                    nextStep = WDONextStep.failed;
-                    break;
-                case WDOIdentityVerificationStatus.rejected:
-                    nextStep = WDONextStep.rejected;
-                    break;
-            }
-        }
-        // DOCUMENT VERIFICATION FINAL PHASE
-        else if (phase === WDOIdentityVerificationPhase.documentVerificationFinal) {
-            switch (status) {
-                case WDOIdentityVerificationStatus.accepted:
-                    nextStep = WDONextStep.statusCheck;
-                    statusCheckReason = exports.WDOStatusCheckReason.documentsCrossVerification;
-                    break;
-                case WDOIdentityVerificationStatus.inProgress:
-                    nextStep = WDONextStep.statusCheck;
-                    statusCheckReason = exports.WDOStatusCheckReason.documentsCrossVerification;
-                    break;
-                case WDOIdentityVerificationStatus.failed:
-                    nextStep = WDONextStep.failed;
-                    break;
-                case WDOIdentityVerificationStatus.rejected:
-                    nextStep = WDONextStep.rejected;
-                    break;
-            }
-        }
-        // CLIENT EVALUATION PHASE
-        else if (phase === WDOIdentityVerificationPhase.clientEvaluation) {
-            switch (status) {
-                case WDOIdentityVerificationStatus.inProgress:
-                    nextStep = WDONextStep.statusCheck;
-                    statusCheckReason = exports.WDOStatusCheckReason.clientVerification;
-                    break;
-                case WDOIdentityVerificationStatus.accepted:
-                    nextStep = WDONextStep.statusCheck;
-                    statusCheckReason = exports.WDOStatusCheckReason.clientAccepted;
-                    break;
-                case WDOIdentityVerificationStatus.rejected:
-                    nextStep = WDONextStep.rejected;
-                    break;
-                case WDOIdentityVerificationStatus.failed:
-                    nextStep = WDONextStep.failed;
-                    break;
-            }
-        }
-        // PRESENCE CHECK PHASE
-        else if (phase === WDOIdentityVerificationPhase.presenceCheck) {
-            switch (status) {
-                case WDOIdentityVerificationStatus.notInitialized:
-                case WDOIdentityVerificationStatus.inProgress:
-                    nextStep = WDONextStep.presenceCheck;
-                    break;
-                case WDOIdentityVerificationStatus.verificationPending:
-                    nextStep = WDONextStep.statusCheck;
-                    statusCheckReason = exports.WDOStatusCheckReason.verifyingPresence;
-                    break;
-                case WDOIdentityVerificationStatus.failed:
-                    nextStep = WDONextStep.failed;
-                    break;
-                case WDOIdentityVerificationStatus.rejected:
-                    nextStep = WDONextStep.rejected;
-                    break;
-            }
-        }
-        // OTP PHASE
-        else if (phase === WDOIdentityVerificationPhase.otp) {
-            switch (status) {
-                case WDOIdentityVerificationStatus.verificationPending:
-                    nextStep = WDONextStep.otp;
-                    break;
-            }
-        }
-        // COMPLETED PHASE
-        else if (phase === WDOIdentityVerificationPhase.completed) {
-            switch (status) {
-                case WDOIdentityVerificationStatus.accepted:
-                    nextStep = WDONextStep.success;
-                    break;
-                case WDOIdentityVerificationStatus.failed:
-                    nextStep = WDONextStep.failed;
-                    break;
-                case WDOIdentityVerificationStatus.rejected:
-                    nextStep = WDONextStep.rejected;
-                    break;
-            }
-        }
-        if (nextStep == undefined) {
-            WDOLogger.error("Unknown phase/status combo: ".concat(phase !== null && phase !== void 0 ? phase : "nil", ", ").concat(status));
-            nextStep = WDONextStep.failed;
-        }
-        this.nextStep = nextStep;
-        this.statusCheckReason = statusCheckReason;
-    }
-    WDOVerificationStatus.prototype.description = function () {
-        var result = this.nextStep.toString();
-        if (this.statusCheckReason) {
-            result += "(".concat(this.statusCheckReason, ")");
-        }
-        return result;
-    };
-    return WDOVerificationStatus;
-}());
-/* @internal */
-var WDONextStep;
-(function (WDONextStep) {
-    WDONextStep["intro"] = "intro";
-    WDONextStep["documentScan"] = "documentScan";
-    WDONextStep["statusCheck"] = "statusCheck";
-    WDONextStep["presenceCheck"] = "presenceCheck";
-    WDONextStep["otp"] = "otp";
-    WDONextStep["failed"] = "failed";
-    WDONextStep["rejected"] = "rejected";
-    WDONextStep["success"] = "success";
-})(WDONextStep || (WDONextStep = {}));
-function documentAction(document) {
-    switch (document.status) {
-        case WDODocumentStatus.accepted:
-            return "proceed";
-        case WDODocumentStatus.uploadInProgress:
-        case WDODocumentStatus.inProgress:
-        case WDODocumentStatus.verificationPending:
-        case WDODocumentStatus.verificationInProgress:
-            return "wait";
-        case WDODocumentStatus.rejected:
-        case WDODocumentStatus.failed:
-            return "error";
-    }
-    WDOLogger.debug("Unknown document status: ".concat(document.status, " for document ID: ").concat(document.id));
-    return "error"; // fallback
-}
-
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Service that can verify previously activated PowerAuth instance.
- *
- * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
- *
- * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
- */
-var WDOVerificationService = /** @class */ (function (_super) {
-    __extends(WDOVerificationService, _super);
-    /**
-     * Creates service instance
-     *
-     * @param powerauth Configured PowerAuth instance. This instance needs to be without valid activation.
-     * @param baseUrl Base URL of the Wultra Digital Onboarding server. Usually ending with `/enrollment-onboarding-server`.
-     */
-    function WDOVerificationService(powerauth, baseUrl) {
-        var _this = _super.call(this) || this;
-        _this.api = new WDOApi(powerauth, baseUrl);
-        _this.powerauth = powerauth;
-        return _this;
-    }
-    /** Checks if verification is required based on PowerAuth activation status */
-    WDOVerificationService.isVerificationRequired = function (paStatus) {
-        var _a;
-        var flags = (_a = paStatus.customObject) === null || _a === void 0 ? void 0 : _a.activationFlags;
-        return !!flags && flags.some(function (f) { return f === "VERIFICATION_PENDING" || f === "VERIFICATION_IN_PROGRESS"; });
-    };
     /* @internal */
-    WDOVerificationService.prototype.fetchActivationStatus = function () {
+    WDOBaseActivationService.prototype.verifyHasActiveProcess = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var result;
+            var pid;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.powerauth.fetchActivationStatus()];
+                    case 0: return [4 /*yield*/, this.processId()];
                     case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, {
-                                state: WDOPowerAuthActivationState[result.state],
-                                failCount: result.failCount,
-                                maxFailCount: result.maxFailCount,
-                                remainingAttempts: result.remainingAttempts,
-                                customObject: result.customObject
-                            }];
+                        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];
                 }
             });
         });
     };
-    /* @internal */
-    WDOVerificationService.prototype.changeAcceptLanguageImpl = function (language) {
-        this.api.networking.acceptLanguage = language;
-    };
-    return WDOVerificationService;
-}(WDOBaseVerificationService));
+    return WDOBaseActivationService;
+}());
 
 /**
  * Copyright Wultra s.r.o.
@@ -1941,7 +2165,15 @@ var WDOVerificationService = /** @class */ (function (_super) {
  */
 /** Service that provides configuration for the Wultra Digital Onboarding SDK. */
 var WDOBaseConfigurationService = /** @class */ (function () {
-    function WDOBaseConfigurationService() {
+    /**
+     * 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 WDOBaseConfigurationService(powerauth, baseUrl) {
+        this.api = new WDOApi(powerauth, baseUrl);
+        this.powerauth = powerauth;
     }
     /**
      * Fetches configuration for the given process type from the server.
@@ -1970,21 +2202,47 @@ var WDOBaseConfigurationService = /** @class */ (function () {
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-
+WDOPlatform.cache = new WDOCordovaCache();
+WDOPlatform.networkingFactory = new WDONetworkingFactoryCordova();
+WDOPlatform.powerAuthFactory = new WDOPowerAuthFactoryCordova();
+/**
+ * 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);
+    function WDOActivationService() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return WDOActivationService;
+}(WDOBaseActivationService));
+/**
+ * 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);
+    function WDOVerificationService() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /** Checks if verification is required based on PowerAuth activation status */
+    WDOVerificationService.isVerificationRequired = function (paStatus) {
+        return _super.isVerificationRequiredInternal.call(this, paStatus);
+    };
+    return WDOVerificationService;
+}(WDOBaseVerificationService));
 /** 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;
+    function WDOConfigurationService() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
     return WDOConfigurationService;
 }(WDOBaseConfigurationService));
@@ -1992,8 +2250,10 @@ var WDOConfigurationService = /** @class */ (function (_super) {
 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;