cordova-digital-onboarding 1.1.0 → 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.
  *
@@ -195,10 +421,14 @@ exports.WDOErrorReason = void 0;
     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 = {}));
 
 /**
@@ -209,10 +439,10 @@ exports.WDOErrorReason = void 0;
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-var WDODefaultCache = /** @class */ (function () {
-    function WDODefaultCache() {
+var WDOPlatform = /** @class */ (function () {
+    function WDOPlatform() {
     }
-    return WDODefaultCache;
+    return WDOPlatform;
 }());
 
 /**
@@ -223,532 +453,63 @@ var WDODefaultCache = /** @class */ (function () {
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * Service that can activate PowerAuth instance by user weak credentials (like his email, phone number or client ID) + optional SMS OTP.
- *
- * When the PowerAuth is activated with this service, `WDOVerificationService.isVerificationRequired` will be `true`
- * and you will need to verify the PowerAuth instance via `WDOVerificationService`.
- *
- * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
- */
-var WDOBaseActivationService = /** @class */ (function () {
-    function WDOBaseActivationService() {
+var WDOApi = /** @class */ (function () {
+    function WDOApi(powerauth, baseUrl) {
+        // TODO: additional configuration?
+        this.networking = WDOPlatform.networkingFactory.networking(powerauth, baseUrl);
     }
-    /**
-     * If the activation process is in progress.
-     *
-     * Note that even if this property is `true` it can be already discontinued on the server.
-     * Calling `status()` for example after the app is launched in this case is recommended.
-     */
-    WDOBaseActivationService.prototype.hasActiveProcess = function () {
-        return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, this.getCachedProcessData()];
-                case 1: return [2 /*return*/, !!(_a.sent())];
-            }
-        }); });
-    };
-    /**
-     * Accept language for the outgoing requests headers.
-     * Default value is "en".
-     *
-     * Standard RFC "Accept-Language" https://tools.ietf.org/html/rfc7231#section-5.3.5
-     * Response texts are based on this setting. For example when "de" is set, server
-     * will return error texts and other in german (if available).
-     */
-    WDOBaseActivationService.prototype.changeAcceptLanguage = function (language) {
-        this.changeAcceptLanguageImpl(language);
-    };
-    /* @internal  */
-    WDOBaseActivationService.prototype.cacheKey = function () { return "wdopd_".concat(this.getPAInstanceId()); };
-    /* @internal  */
-    WDOBaseActivationService.prototype.setCachedProcessData = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, WDODefaultCache.instance.set(this.cacheKey(), JSON.stringify(data))];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /* @internal  */
-    WDOBaseActivationService.prototype.getCachedProcessData = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, WDODefaultCache.instance.get(this.cacheKey())];
-                    case 1:
-                        data = _a.sent();
-                        if (!data) {
-                            return [2 /*return*/, undefined];
-                        }
-                        return [2 /*return*/, JSON.parse(data)];
-                }
-            });
-        });
-    };
-    /* @internal  */
-    WDOBaseActivationService.prototype.processId = function () {
-        return __awaiter(this, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, this.getCachedProcessData()];
-                case 1: return [2 /*return*/, (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.processId];
-            }
-        }); });
-    };
-    // PUBLIC API
-    /**
-     * Retrieves status of the onboarding activation.
-     *
-     * @return Promise resolved with onboarding status.
-     */
-    WDOBaseActivationService.prototype.status = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, _b, _c, pid, result;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _b = (_a = WDOLogger).debug;
-                        _c = "Getting activation status for processId=".concat;
-                        return [4 /*yield*/, this.processId()];
-                    case 1:
-                        _b.apply(_a, [_c.apply("Getting activation status for processId=", [_d.sent()])]);
-                        return [4 /*yield*/, this.verifyCanStartActivation()];
-                    case 2:
-                        _d.sent();
-                        return [4 /*yield*/, this.verifyHasActiveProcess()];
-                    case 3:
-                        pid = _d.sent();
-                        return [4 /*yield*/, this.api.activationGetStatus(pid)];
-                    case 4:
-                        result = _d.sent();
-                        return [2 /*return*/, result.onboardingStatus];
-                }
-            });
-        });
-    };
-    /**
-     * Start onboarding activation with user credentials.
-     *
-     * For example, when you require email and birth date, your object would look like this:
-     * ```
-     * {
-     *   email: "<user_email>",
-     *   birthdate: "<user_birth_date>"
-     * }
-     * ```
-     * @param credentials Object with credentials. Which credentials are needed should be provided by a system/backend provider.
-     * @param processType The process type identification. If not specified, the default process type will be used.
-     */
-    WDOBaseActivationService.prototype.start = function (credentials, processType) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WDOLogger.debug("Starting activation with credentials: ".concat(JSON.stringify(credentials)));
-                        return [4 /*yield*/, this.processId()];
-                    case 1:
-                        if (_a.sent()) {
-                            throw new WDOError(exports.WDOErrorReason.processAlreadyInProgress, "Cannot start the process - processId already obtained, cancel first.");
-                        }
-                        return [4 /*yield*/, this.verifyCanStartActivation()];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, this.api.activationStart(credentials, processType)];
-                    case 3:
-                        result = _a.sent();
-                        WDOLogger.info("WDOActivationService.start success");
-                        WDOLogger.debug(" - processId: ".concat(result.processId));
-                        return [4 /*yield*/, this.setCachedProcessData({ processId: result.processId, activationCode: result.activationCode })];
-                    case 4:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Cancel the activation process (issues a cancel request to the backend and clears the local process ID).
-     *
-     * @param forceCancel When true, the process will be canceled in the SDK even when fails on backend. `true` by default.
-     */
-    WDOBaseActivationService.prototype.cancel = function () {
-        return __awaiter(this, arguments, void 0, function (forceCancel) {
-            var _a, _b, _c, pid, error_1;
-            if (forceCancel === void 0) { forceCancel = true; }
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _b = (_a = WDOLogger).debug;
-                        _c = "Canceling activation for processId=".concat;
-                        return [4 /*yield*/, this.processId()];
-                    case 1:
-                        _b.apply(_a, [_c.apply("Canceling activation for processId=", [_d.sent(), ", forceCancel="]).concat(forceCancel)]);
-                        return [4 /*yield*/, this.verifyHasActiveProcess()];
-                    case 2:
-                        pid = _d.sent();
-                        _d.label = 3;
-                    case 3:
-                        _d.trys.push([3, 6, , 10]);
-                        return [4 /*yield*/, this.api.activationCancel(pid)];
-                    case 4:
-                        _d.sent();
-                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
-                    case 5:
-                        _d.sent();
-                        WDOLogger.info("WDOActivationService.cancel success");
-                        return [3 /*break*/, 10];
-                    case 6:
-                        error_1 = _d.sent();
-                        if (!forceCancel) return [3 /*break*/, 8];
-                        // pretend it was successful and just log the error
-                        WDOLogger.debug("Process canceled (but the request failed) - ".concat(error_1, "."));
-                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
-                    case 7:
-                        _d.sent();
-                        return [3 /*break*/, 9];
-                    case 8: throw error_1; // rethrow
-                    case 9: return [3 /*break*/, 10];
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /** Clear the stored data (without networking call). */
-    WDOBaseActivationService.prototype.clear = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.setCachedProcessData(undefined)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * OTP resend request.
-     *
-     * This is intended to be displayed for the user to use in case of the OTP is not received.
-     * For example, when the user does not receive SMS after some time, there should be a button to "send again".
-     */
-    WDOBaseActivationService.prototype.resendOTP = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WDOLogger.debug("Activation: resending OTP");
-                        return [4 /*yield*/, this.verifyHasActiveProcess()];
-                    case 1:
-                        pid = _a.sent();
-                        return [4 /*yield*/, this.verifyCanStartActivation()];
-                    case 2:
-                        _a.sent();
-                        return [4 /*yield*/, this.api.activationResendOTP(pid)];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * @internal
-     * Demo endpoint available only in Wultra Demo systems.
-     *
-     * If the app is running against our demo server, you can retrieve the OTP without needing to send SMS or emails.
-     */
-    WDOBaseActivationService.prototype.getOTP = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WDOLogger.debug("Activation: getting OTP from server (only for testing purposes)");
-                        return [4 /*yield*/, this.verifyHasActiveProcess()];
-                    case 1:
-                        pid = _a.sent();
-                        return [4 /*yield*/, this.api.activationGetOTP(pid, "ACTIVATION")];
-                    case 2: return [2 /*return*/, (_a.sent()).otpCode];
-                }
-            });
-        });
-    };
-    /**
-     * Activate the PowerAuth instance that was passed in the initializer.
-     *
-     * @param activationName Name of the activation. Usually something like John's iPhone or similar.
-     * @param otp OTP code received by the user (via SMS or email). Optional when not required.
-     * @return Promise resolved with activation result.
-     */
-    WDOBaseActivationService.prototype.activate = function (activationName, otp) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid, code, result, identityAttributes, error_2;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        WDOLogger.debug("Activating the PowerAuth with activation name '".concat(activationName, "'"));
-                        return [4 /*yield*/, this.verifyCanStartActivation()];
-                    case 1:
-                        _b.sent();
-                        return [4 /*yield*/, this.verifyHasActiveProcess()];
-                    case 2:
-                        pid = _b.sent();
-                        return [4 /*yield*/, this.getCachedProcessData()];
-                    case 3:
-                        code = (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.activationCode;
-                        _b.label = 4;
-                    case 4:
-                        _b.trys.push([4, 9, , 10]);
-                        if (!code) return [3 /*break*/, 6];
-                        WDOLogger.info("Activating PowerAuth using activation code from the onboarding process");
-                        return [4 /*yield*/, this.activatePowerAuthWithCode(code, otp, activationName)];
-                    case 5:
-                        result = _b.sent();
-                        return [3 /*break*/, 8];
-                    case 6:
-                        WDOLogger.info("Activating PowerAuth using identity attributes from the onboarding process");
-                        identityAttributes = { processId: pid, otpCode: otp, credentialsType: "ONBOARDING" };
-                        return [4 /*yield*/, this.activatePowerAuth(identityAttributes, activationName)];
-                    case 7:
-                        result = _b.sent();
-                        _b.label = 8;
-                    case 8: return [3 /*break*/, 10];
-                    case 9:
-                        error_2 = _b.sent();
-                        throw new WDOError(exports.WDOErrorReason.activationFailed, "Activation failed", error_2);
-                    case 10: 
-                    // Clear process ID after activation attempt
-                    return [4 /*yield*/, this.setCachedProcessData(undefined)];
-                    case 11:
-                        // Clear process ID after activation attempt
-                        _b.sent();
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    // PRIVATE METHODS
-    /* @internal */
-    WDOBaseActivationService.prototype.verifyCanStartActivation = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.api.canStartActivation()];
-                    case 1:
-                        if (!!(_a.sent())) return [3 /*break*/, 3];
-                        WDOLogger.error("PowerAuth is already activated - Activation cannot be started/processed.");
-                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
-                    case 2:
-                        _a.sent();
-                        throw new WDOError(exports.WDOErrorReason.powerauthAlreadyActivated, "PowerAuth is already activated");
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /* @internal */
-    WDOBaseActivationService.prototype.verifyHasActiveProcess = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var pid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.processId()];
-                    case 1:
-                        pid = _a.sent();
-                        if (!pid) {
-                            WDOLogger.warn("Cannot proceed (processId not available).");
-                            throw new WDOError(exports.WDOErrorReason.processNotInProgress, "No active activation process");
-                        }
-                        return [2 /*return*/, pid];
-                }
-            });
-        });
-    };
-    return WDOBaseActivationService;
-}());
-
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-var WDOActivationEndpoints = /** @class */ (function () {
-    function WDOActivationEndpoints() {
-    }
-    WDOActivationEndpoints.start = {
-        path: "/api/onboarding/start",
-        e2eeScope: "APPLICATION",
-        returnsData: true
-    };
-    WDOActivationEndpoints.cancel = {
-        path: "/api/onboarding/cleanup",
-        e2eeScope: "APPLICATION",
-        returnsData: false
-    };
-    WDOActivationEndpoints.resendOTP = {
-        path: "/api/onboarding/otp/resend",
-        e2eeScope: "APPLICATION",
-        returnsData: false
-    };
-    WDOActivationEndpoints.getStatus = {
-        path: "/api/onboarding/status",
-        e2eeScope: "APPLICATION",
-        returnsData: true
-    };
-    return WDOActivationEndpoints;
-}());
-var WDOVerificationEndpoints = /** @class */ (function () {
-    function WDOVerificationEndpoints() {
-    }
-    WDOVerificationEndpoints.getStatus = {
-        path: "/api/identity/status",
-        e2eeScope: "NONE",
-        tokenName: "possession_universal",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.init = {
-        path: "/api/identity/init",
-        uriId: "/api/identity/init",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.cancel = {
-        path: "/api/identity/cleanup",
-        uriId: "/api/identity/cleanup",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.consentText = {
-        path: "/api/identity/consent/text",
-        tokenName: "possession_universal",
-        e2eeScope: "NONE",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.consentApprove = {
-        path: "/api/identity/consent/approve",
-        uriId: "/api/identity/consent/approve",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.documentScanSdkInit = {
-        path: "/api/identity/document/init-sdk",
-        uriId: "/api/identity/document/init-sdk",
-        e2eeScope: "ACTIVATION",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.v2submitDocuments = {
-        path: "/api/v2/identity/document/submit",
-        tokenName: "possession_universal",
-        e2eeScope: "ACTIVATION",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.documentsStatus = {
-        path: "/api/identity/document/status",
-        tokenName: "possession_universal",
-        e2eeScope: "NONE",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.presenceCheckInit = {
-        path: "/api/identity/presence-check/init",
-        uriId: "/api/identity/presence-check/init",
-        e2eeScope: "ACTIVATION",
-        returnsData: true
-    };
-    WDOVerificationEndpoints.presenceCheckSubmit = {
-        path: "/api/identity/presence-check/submit",
-        uriId: "/api/identity/presence-check/submit",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.resendOTP = {
-        path: "/api/identity/otp/resend",
-        uriId: "/api/identity/otp/resend",
-        e2eeScope: "NONE",
-        returnsData: false
-    };
-    WDOVerificationEndpoints.verifyOTP = {
-        path: "/api/identity/otp/verify",
-        e2eeScope: "ACTIVATION",
-        returnsData: true
-    };
-    return WDOVerificationEndpoints;
-}());
-
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-var WDOBaseApi = /** @class */ (function () {
-    function WDOBaseApi() {
-    }
-    // Configuration endpoints
-    WDOBaseApi.prototype.getConfiguration = function (processType) {
-        var requestObject = { processType: processType };
-        return this.callApi(requestObject, { path: "/api/configuration", e2eeScope: "APPLICATION", returnsData: true });
+    // Configuration endpoints
+    WDOApi.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) {
+    WDOApi.prototype.activationStart = function (credentials, processType) {
         var requestObject = { identification: credentials, processType: processType };
         return this.callApi(requestObject, WDOActivationEndpoints.start);
     };
-    WDOBaseApi.prototype.activationCancel = function (processId) {
+    WDOApi.prototype.activationCancel = function (processId) {
         var requestObject = { processId: processId };
         return this.callApi(requestObject, WDOActivationEndpoints.cancel);
     };
-    WDOBaseApi.prototype.activationGetStatus = function (processId) {
+    WDOApi.prototype.activationGetStatus = function (processId) {
         var requestObject = { processId: processId };
         return this.callApi(requestObject, WDOActivationEndpoints.getStatus);
     };
-    WDOBaseApi.prototype.activationResendOTP = function (processId) {
+    WDOApi.prototype.activationResendOTP = function (processId) {
         var requestObject = { processId: processId };
         return this.callApi(requestObject, WDOActivationEndpoints.resendOTP);
     };
-    WDOBaseApi.prototype.activationGetOTP = function (processId, otpType) {
+    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 });
     };
     // Verification endpoints
-    WDOBaseApi.prototype.verificationStatus = function () {
+    WDOApi.prototype.verificationStatus = function () {
         var requestObject = {};
         return this.callApi(requestObject, WDOVerificationEndpoints.getStatus);
     };
-    WDOBaseApi.prototype.verificationStart = function (processId) {
+    WDOApi.prototype.verificationStart = function (processId) {
         var requestObject = { processId: processId };
         return this.callApi(requestObject, WDOVerificationEndpoints.init);
     };
-    WDOBaseApi.prototype.verificationCleanup = function (processId) {
+    WDOApi.prototype.verificationCleanup = function (processId) {
         var requestObject = { processId: processId };
         return this.callApi(requestObject, WDOVerificationEndpoints.cancel);
     };
-    WDOBaseApi.prototype.verificationGetConsentText = function (processId) {
+    WDOApi.prototype.verificationGetConsentText = function (processId) {
         var requestObject = { processId: processId, consentType: "GDPR" };
         return this.callApi(requestObject, WDOVerificationEndpoints.consentText);
     };
-    WDOBaseApi.prototype.verificationResolveConsent = function (processId, approved) {
+    WDOApi.prototype.verificationResolveConsent = function (processId, approved) {
         var requestObject = { processId: processId, approved: approved, consentType: "GDPR" };
         return this.callApi(requestObject, WDOVerificationEndpoints.consentApprove);
     };
-    WDOBaseApi.prototype.verificationInitScanSDK = function (processId, challenge) {
+    WDOApi.prototype.verificationInitScanSDK = function (processId, challenge) {
         var requestObject = { processId: processId, attributes: { 'sdk-init-token': challenge } };
         return this.callApi(requestObject, WDOVerificationEndpoints.documentScanSdkInit);
     };
-    WDOBaseApi.prototype.verificationSubmitDocuments = function (processId, resubmit, documents) {
+    WDOApi.prototype.verificationSubmitDocuments = function (processId, resubmit, documents) {
         var requestObject = {
             processId: processId,
             resubmit: resubmit,
@@ -757,54 +518,40 @@ var WDOBaseApi = /** @class */ (function () {
         // TODO: there should be longer timeout!
         return this.callApi(requestObject, WDOVerificationEndpoints.v2submitDocuments);
     };
-    WDOBaseApi.prototype.verificationDocumentsStatus = function (processId) {
+    WDOApi.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;
             }
@@ -820,129 +567,29 @@ var WDOApi = /** @class */ (function (_super) {
             }
         });
     };
-    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.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Service that can activate PowerAuth instance by user weak credentials (like his email, phone number or client ID) + optional SMS OTP.
- *
- * When the PowerAuth is activated with this service, `WDOVerificationService.isVerificationRequired` will be `true`
- * and you will need to verify the PowerAuth instance via `WDOVerificationService`.
- *
- * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
- */
-var WDOActivationService = /** @class */ (function (_super) {
-    __extends(WDOActivationService, _super);
-    /**
-     * Creates service instance
-     *
-     * @param powerauth Configured PowerAuth instance. This instance needs to be without valid activation.
-     * @param baseUrl Base URL of the Wultra Digital Onboarding server. Usually ending with `/enrollment-onboarding-server`.
-     */
-    function WDOActivationService(powerauth, baseUrl) {
-        var _this = _super.call(this) || this;
-        _this.api = new WDOApi(powerauth, baseUrl);
-        _this.powerauth = powerauth;
-        return _this;
-    }
-    /* @internal */
-    WDOActivationService.prototype.activatePowerAuth = function (identityAttributes, activationName) {
-        var activation = PowerAuthActivation.createWithIdentityAttributes(identityAttributes, activationName);
-        return this.powerauth.createActivation(activation);
-    };
-    /* @internal */
-    WDOActivationService.prototype.activatePowerAuthWithCode = function (activationCode, otp, activationName) {
-        var activation = PowerAuthActivation.createWithActivationCode(activationCode, activationName);
-        if (otp) {
-            activation.additionalActivationOtp = otp;
-        }
-        return this.powerauth.createActivation(activation);
-    };
-    /* @internal */
-    WDOActivationService.prototype.changeAcceptLanguageImpl = function (language) {
-        this.api.networking.acceptLanguage = language;
-    };
-    /* @internal */
-    WDOActivationService.prototype.getPAInstanceId = function () {
-        return this.powerauth.instanceId;
-    };
-    return WDOActivationService;
-}(WDOBaseActivationService));
-
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * The `WDOPowerAuthActivationState` enum defines all possible states of activation.
- * The state is a part of information received together with the rest
- * of the `WDOPowerAuthActivationStatus` object.
- */
-var WDOPowerAuthActivationState;
-(function (WDOPowerAuthActivationState) {
-    /**
-     * The activation is just created.
-     */
-    WDOPowerAuthActivationState["CREATED"] = "CREATED";
-    /**
-     * The activation is not completed yet on the server.
-     */
-    WDOPowerAuthActivationState["PENDING_COMMIT"] = "PENDING_COMMIT";
-    /**
-     * The shared secure context is valid and active.
-     */
-    WDOPowerAuthActivationState["ACTIVE"] = "ACTIVE";
-    /**
-     * The activation is blocked.
-     */
-    WDOPowerAuthActivationState["BLOCKED"] = "BLOCKED";
-    /**
-     * The activation doesn't exist anymore.
-     */
-    WDOPowerAuthActivationState["REMOVED"] = "REMOVED";
-    /**
-     * The activation is technically blocked. You cannot use it anymore
-     * for the signature calculations.
-     */
-    WDOPowerAuthActivationState["DEADLOCK"] = "DEADLOCK";
-})(WDOPowerAuthActivationState || (WDOPowerAuthActivationState = {}));
+}());
 
 /**
  * Copyright Wultra s.r.o.
@@ -964,7 +611,7 @@ exports.WDOOnboardingStatus = void 0;
     /** Onboarding process is completed */
     WDOOnboardingStatus["finished"] = "FINISHED";
 })(exports.WDOOnboardingStatus || (exports.WDOOnboardingStatus = {}));
-/** Status of the current identity verification */
+/* @internal */
 exports.WDOIdentityVerificationStatus = void 0;
 (function (WDOIdentityVerificationStatus) {
     /** Identity verification is waiting for initialization */
@@ -980,7 +627,7 @@ exports.WDOIdentityVerificationStatus = void 0;
     /** Identity verification was rejected */
     WDOIdentityVerificationStatus["rejected"] = "REJECTED";
 })(exports.WDOIdentityVerificationStatus || (exports.WDOIdentityVerificationStatus = {}));
-/** Phase of the current identity verification */
+/* @internal */
 exports.WDOIdentityVerificationPhase = void 0;
 (function (WDOIdentityVerificationPhase) {
     /** Document upload is in progress */
@@ -997,8 +644,10 @@ exports.WDOIdentityVerificationPhase = void 0;
     WDOIdentityVerificationPhase["otp"] = "OTP_VERIFICATION";
     /** Completed */
     WDOIdentityVerificationPhase["completed"] = "COMPLETED";
+    /** Exchanging the temporary activation for the permanent one. */
+    WDOIdentityVerificationPhase["activationFinish"] = "ACTIVATION_FINISH";
 })(exports.WDOIdentityVerificationPhase || (exports.WDOIdentityVerificationPhase = {}));
-/** Types of available documents */
+/* @internal */
 exports.WDODocumentSubmitFileType = void 0;
 (function (WDODocumentSubmitFileType) {
     /** National ID card */
@@ -1010,7 +659,7 @@ exports.WDODocumentSubmitFileType = void 0;
     /** Selfie photo */
     WDODocumentSubmitFileType["selfiePhoto"] = "SELFIE_PHOTO";
 })(exports.WDODocumentSubmitFileType || (exports.WDODocumentSubmitFileType = {}));
-/** Side of the file */
+/* @internal */
 exports.WDODocumentSubmitFileSide = void 0;
 (function (WDODocumentSubmitFileSide) {
     /** Front side of an document. Usually the one with the picture */
@@ -1018,7 +667,7 @@ exports.WDODocumentSubmitFileSide = void 0;
     /** Back side of an document */
     WDODocumentSubmitFileSide["back"] = "BACK";
 })(exports.WDODocumentSubmitFileSide || (exports.WDODocumentSubmitFileSide = {}));
-/** Status of the document */
+/* @internal */
 exports.WDODocumentStatus = void 0;
 (function (WDODocumentStatus) {
     /** Document was accepted */
@@ -1037,110 +686,6 @@ exports.WDODocumentStatus = void 0;
     WDODocumentStatus["failed"] = "FAILED";
 })(exports.WDODocumentStatus || (exports.WDODocumentStatus = {}));
 
-/**
- * Copyright Wultra s.r.o.
- *
- * This source code is licensed under the Apache License, Version 2.0 license
- * found in the LICENSE file in the root directory of this source tree.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-/** Types of the verification state */
-exports.WDOVerificationStateType = void 0;
-(function (WDOVerificationStateType) {
-    /**
-     * Show the verification introduction screen where the user can start the activation.
-     *
-     * The next step should be calling the `start()`.
-     */
-    WDOVerificationStateType["intro"] = "intro";
-    /**
-     * Show document selection to the user. Which documents are available and how many
-     * can the user select is up to your backend configuration.
-     *
-     * The next step should be calling the `documentsSetSelectedTypes`.
-     */
-    WDOVerificationStateType["documentsToScanSelect"] = "documentsToScanSelect";
-    /**
-     * User should scan documents - display UI for the user to scan all necessary documents.
-     *
-     * The next step should be calling the `documentsSubmit`.
-     */
-    WDOVerificationStateType["scanDocument"] = "scanDocument";
-    /**
-     * The system is processing data - show loading with text hint from provided `WDOStatusCheckReason`.
-     *
-     * The next step should be calling the `status`.
-     */
-    WDOVerificationStateType["processing"] = "processing";
-    /**
-     * The user should be presented with a presence check.
-     * Presence check is handled by third-party SDK based on the project setup.
-     *
-     * The next step should be calling the `presenceCheckInit` to start the check and `presenceCheckSubmit` to
-     * mark it finished.  Note that these methods won't change the status and it's up to the app to handle the process of the presence check.
-     */
-    WDOVerificationStateType["presenceCheck"] = "presenceCheck";
-    /**
-     * Show enter OTP screen with resend button.
-     *
-     * The next step should be calling the `verifyOTP` with user-entered OTP.
-     * The OTP is usually SMS or email.
-     */
-    WDOVerificationStateType["otp"] = "otp";
-    /**
-     * Verification failed and can be restarted
-     *
-     * The next step should be calling the `restartVerification` or `cancelWholeProcess` based on
-     * the user's decision if he wants to try it again or cancel the process.
-     */
-    WDOVerificationStateType["failed"] = "failed";
-    /**
-     * Verification is canceled and the user needs to start again with a new PowerAuth activation.
-     *
-     * The next step should be calling the `PowerAuth.removeActivationLocal()` and starting activation from scratch.
-     */
-    WDOVerificationStateType["endState"] = "endState";
-    /**
-     * Verification was successfully ended. Continue into your app flow.
-     */
-    WDOVerificationStateType["success"] = "success";
-})(exports.WDOVerificationStateType || (exports.WDOVerificationStateType = {}));
-/** The reason why the process ended in a non-recoverable state. */
-exports.WDOEndStateReason = void 0;
-(function (WDOEndStateReason) {
-    /**
-     * The verification was rejected by the system
-     *
-     * eg: Fake information, fraud detection, or user is trying repeatedly in a short time.
-     * The real reason is not presented to the user and is only audited on the server.
-     */
-    WDOEndStateReason["rejected"] = "rejected";
-    /**
-     * The limit of repeat tries was reached. There is a fixed number of tries that the user can reach
-     * before the system stops the process.
-     */
-    WDOEndStateReason["limitReached"] = "limitReached";
-    /** An unknown reason. */
-    WDOEndStateReason["other"] = "other";
-})(exports.WDOEndStateReason || (exports.WDOEndStateReason = {}));
-/**
- * The reason for what we are waiting for. For example, we can wait for documents to be OCRed and matched against the database.
- * Use these values for better loading texts to tell the user what is happening - some tasks may take some time
- * and it would be frustrating to just show a generic loading indicator.
- */
-exports.WDOStatusCheckReason = void 0;
-(function (WDOStatusCheckReason) {
-    WDOStatusCheckReason["unknown"] = "unknown";
-    WDOStatusCheckReason["documentUpload"] = "documentUpload";
-    WDOStatusCheckReason["documentVerification"] = "documentVerification";
-    WDOStatusCheckReason["documentAccepted"] = "documentAccepted";
-    WDOStatusCheckReason["documentsCrossVerification"] = "documentsCrossVerification";
-    WDOStatusCheckReason["clientVerification"] = "clientVerification";
-    WDOStatusCheckReason["clientAccepted"] = "clientAccepted";
-    WDOStatusCheckReason["verifyingPresence"] = "verifyingPresence";
-})(exports.WDOStatusCheckReason || (exports.WDOStatusCheckReason = {}));
-
 /**
  * Copyright Wultra s.r.o.
  *
@@ -1193,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) {
@@ -1220,7 +749,7 @@ exports.WDODocumentSide = void 0;
     /** Back side of a document */
     WDODocumentSide["back"] = "back";
 })(exports.WDODocumentSide || (exports.WDODocumentSide = {}));
-/** Converts WDODocumentType to WDODocumentSubmitFileType */
+/* @internal */
 function WDODocumentTypeToSubmitType(type) {
     switch (type) {
         case exports.WDODocumentType.idCard:
@@ -1231,7 +760,7 @@ function WDODocumentTypeToSubmitType(type) {
             return exports.WDODocumentSubmitFileType.driversLicense;
     }
 }
-/** Converts WDODocumentSide to DocumentSubmitFileSide */
+/* @internal */
 function WDOCreateDocumentSubmitFileSide(side) {
     switch (side) {
         case exports.WDODocumentSide.front:
@@ -1384,18 +913,33 @@ exports.WDOConsentResponse = void 0;
  * 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() {
+    /**
+     * 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.getPAInstanceId()); };
+    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*/, WDODefaultCache.instance.set(this.cacheKey(), process === null || process === void 0 ? void 0 : process.dataForCache())];
+                    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*/];
@@ -1409,7 +953,7 @@ var WDOBaseVerificationService = /** @class */ (function () {
             var data;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, WDODefaultCache.instance.get(this.cacheKey())];
+                    case 0: return [4 /*yield*/, WDOPlatform.cache.get(this.cacheKey())];
                     case 1:
                         data = _a.sent();
                         if (!data) {
@@ -1430,7 +974,7 @@ var WDOBaseVerificationService = /** @class */ (function () {
      * will return error texts and other in german (if available).
      */
     WDOBaseVerificationService.prototype.changeAcceptLanguage = function (language) {
-        this.changeAcceptLanguageImpl(language);
+        this.api.networking.acceptLanguage = language;
     };
     Object.defineProperty(WDOBaseVerificationService.prototype, "otpResendPeriodSeconds", {
         /** Time in seconds that user needs to wait between OTP resend calls */
@@ -1447,17 +991,20 @@ var WDOBaseVerificationService = /** @class */ (function () {
     WDOBaseVerificationService.prototype.status = function () {
         return __awaiter(this, void 0, void 0, function () {
             var response, _a, vf, _b, docsResponse, documents, cachedProcess, error_1;
-            var _c, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        _e.trys.push([0, 17, , 18]);
+                        _d.trys.push([0, 18, , 19]);
                         return [4 /*yield*/, this.api.verificationStatus()];
                     case 1:
-                        response = _e.sent();
-                        response.consentRequired = (_c = response.consentRequired) !== null && _c !== void 0 ? _c : false; // when undefined, assume false
+                        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];
@@ -1470,7 +1017,7 @@ var WDOBaseVerificationService = /** @class */ (function () {
                         WDOLogger.debug("Status ".concat(response.identityVerificationStatus, " - clearing cache"));
                         return [4 /*yield*/, this.setCachedProcess(undefined)];
                     case 3:
-                        _e.sent();
+                        _d.sent();
                         return [3 /*break*/, 5];
                     case 4: 
                     // no-op
@@ -1489,19 +1036,20 @@ var WDOBaseVerificationService = /** @class */ (function () {
                             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*/, 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 = _e.sent();
+                        docsResponse = _d.sent();
                         WDOLogger.debug("Documents status: ".concat(JSON.stringify(docsResponse)));
                         documents = docsResponse.documents;
                         return [4 /*yield*/, this.getCachedProcess()];
                     case 9:
-                        cachedProcess = _e.sent();
+                        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; })) {
@@ -1534,17 +1082,18 @@ var WDOBaseVerificationService = /** @class */ (function () {
                         }
                     case 10: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.presenceCheck })];
                     case 11: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.otp })];
-                    case 12: return [2 /*return*/, this.processSuccess({ type: exports.WDOVerificationStateType.processing, item: (_d = vf.statusCheckReason) !== null && _d !== void 0 ? _d : exports.WDOStatusCheckReason.unknown })];
+                    case 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 [3 /*break*/, 18];
-                    case 17:
-                        error_1 = _e.sent();
+                    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 18: return [2 /*return*/];
+                    case 19: return [2 /*return*/];
                 }
             });
         });
@@ -1810,6 +1359,78 @@ var WDOBaseVerificationService = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 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.
      *
@@ -1888,10 +1509,10 @@ var WDOBaseVerificationService = /** @class */ (function () {
                         _c.label = 1;
                     case 1:
                         _c.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.fetchActivationStatus()];
+                        return [4 /*yield*/, this.powerauth.fetchActivationStatus()];
                     case 2:
                         status_1 = _c.sent();
-                        if (status_1.state !== WDOPowerAuthActivationState.ACTIVE) {
+                        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")];
@@ -2043,6 +1664,10 @@ var WDOVerificationStatus = /** @class */ (function () {
                     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;
@@ -2067,6 +1692,7 @@ var WDONextStep;
     WDONextStep["statusCheck"] = "statusCheck";
     WDONextStep["presenceCheck"] = "presenceCheck";
     WDONextStep["otp"] = "otp";
+    WDONextStep["finishActivation"] = "finishActivation";
     WDONextStep["failed"] = "failed";
     WDONextStep["rejected"] = "rejected";
     WDONextStep["success"] = "success";
@@ -2097,63 +1723,437 @@ function documentAction(document) {
  * SPDX-License-Identifier: Apache-2.0
  */
 
+
+var WDOCordovaCache = /** @class */ (function () {
+    function WDOCordovaCache() {
+    }
+    WDOCordovaCache.prototype.set = function (key, value) {
+        if (value) {
+            return PowerAuthStorageUtils.setString(key, value, PowerAuthStorageType.SECURE);
+        }
+        else {
+            return PowerAuthStorageUtils.remove(key, PowerAuthStorageType.SECURE).then(function () { });
+        }
+    };
+    WDOCordovaCache.prototype.get = function (key) {
+        return PowerAuthStorageUtils.getString(key, PowerAuthStorageType.SECURE);
+    };
+    WDOCordovaCache.prototype.has = function (key) {
+        return PowerAuthStorageUtils.exists(key, PowerAuthStorageType.SECURE);
+    };
+    return WDOCordovaCache;
+}());
+var WDONetworkingFactoryCordova = /** @class */ (function () {
+    function WDONetworkingFactoryCordova() {
+    }
+    WDONetworkingFactoryCordova.prototype.signedEndpoint = function (path, uriId, responseConfig, e2eeConfig) {
+        return WPNEndpoint.signed(path, uriId, responseConfig, e2eeConfig);
+    };
+    WDONetworkingFactoryCordova.prototype.signedWithTokenEndpoint = function (path, tokenName, responseConfig, e2eeConfig) {
+        return WPNEndpoint.signedWithToken(path, tokenName, responseConfig, e2eeConfig);
+    };
+    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;
+}());
+
 /**
- * Service that can verify previously activated PowerAuth instance.
+ * Copyright Wultra s.r.o.
  *
- * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
+ * 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 WDOVerificationService = /** @class */ (function (_super) {
-    __extends(WDOVerificationService, _super);
+var WDOBaseActivationService = /** @class */ (function () {
+    // PUBLIC API
+    /**
+     * 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 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 () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, WDOPlatform.cache.set(this.cacheKey, JSON.stringify(data))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /* @internal  */
+    WDOBaseActivationService.prototype.getCachedProcessData = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, WDOPlatform.cache.get(this.cacheKey)];
+                    case 1:
+                        data = _a.sent();
+                        if (!data) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, JSON.parse(data)];
+                }
+            });
+        });
+    };
+    /* @internal  */
+    WDOBaseActivationService.prototype.processId = function () {
+        return __awaiter(this, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, this.getCachedProcessData()];
+                case 1: return [2 /*return*/, (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.processId];
+            }
+        }); });
+    };
+    /**
+     * 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.
+     */
+    WDOBaseActivationService.prototype.hasActiveProcess = function () {
+        return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, this.getCachedProcessData()];
+                case 1: return [2 /*return*/, !!(_a.sent())];
+            }
+        }); });
+    };
+    /**
+     * Accept language for the outgoing requests headers.
+     * Default value is "en".
+     *
+     * Standard RFC "Accept-Language" https://tools.ietf.org/html/rfc7231#section-5.3.5
+     * Response texts are based on this setting. For example when "de" is set, server
+     * will return error texts and other in german (if available).
+     */
+    WDOBaseActivationService.prototype.changeAcceptLanguage = function (language) {
+        this.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 _a, _b, _c, pid, result;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = WDOLogger).debug;
+                        _c = "Getting activation status for processId=".concat;
+                        return [4 /*yield*/, this.processId()];
+                    case 1:
+                        _b.apply(_a, [_c.apply("Getting activation status for processId=", [_d.sent()])]);
+                        return [4 /*yield*/, this.verifyCanStartActivation()];
+                    case 2:
+                        _d.sent();
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
+                    case 3:
+                        pid = _d.sent();
+                        return [4 /*yield*/, this.api.activationGetStatus(pid)];
+                    case 4:
+                        result = _d.sent();
+                        return [2 /*return*/, result.onboardingStatus];
+                }
+            });
+        });
+    };
+    /**
+     * Start onboarding activation with user credentials.
+     *
+     * For example, when you require email and birth date, your object would look like this:
+     * ```
+     * {
+     *   email: "<user_email>",
+     *   birthdate: "<user_birth_date>"
+     * }
+     * ```
+     * @param credentials Object with credentials. Which credentials are needed should be provided by a system/backend provider.
+     * @param processType The process type identification. If not specified, the default process type will be used.
+     */
+    WDOBaseActivationService.prototype.start = function (credentials, processType) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Starting activation with credentials: ".concat(JSON.stringify(credentials)));
+                        return [4 /*yield*/, this.processId()];
+                    case 1:
+                        if (_a.sent()) {
+                            throw new WDOError(exports.WDOErrorReason.processAlreadyInProgress, "Cannot start the process - processId already obtained, cancel first.");
+                        }
+                        return [4 /*yield*/, this.verifyCanStartActivation()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.api.activationStart(credentials, processType)];
+                    case 3:
+                        result = _a.sent();
+                        WDOLogger.info("WDOActivationService.start success");
+                        WDOLogger.debug(" - processId: ".concat(result.processId));
+                        return [4 /*yield*/, this.setCachedProcessData({ processId: result.processId, activationCode: result.activationCode })];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Cancel the activation process (issues a cancel request to the backend and clears the local process ID).
+     *
+     * @param forceCancel When true, the process will be canceled in the SDK even when fails on backend. `true` by default.
+     */
+    WDOBaseActivationService.prototype.cancel = function () {
+        return __awaiter(this, arguments, void 0, function (forceCancel) {
+            var _a, _b, _c, pid, error_1;
+            if (forceCancel === void 0) { forceCancel = true; }
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = WDOLogger).debug;
+                        _c = "Canceling activation for processId=".concat;
+                        return [4 /*yield*/, this.processId()];
+                    case 1:
+                        _b.apply(_a, [_c.apply("Canceling activation for processId=", [_d.sent(), ", forceCancel="]).concat(forceCancel)]);
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
+                    case 2:
+                        pid = _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _d.trys.push([3, 6, , 10]);
+                        return [4 /*yield*/, this.api.activationCancel(pid)];
+                    case 4:
+                        _d.sent();
+                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 5:
+                        _d.sent();
+                        WDOLogger.info("WDOActivationService.cancel success");
+                        return [3 /*break*/, 10];
+                    case 6:
+                        error_1 = _d.sent();
+                        if (!forceCancel) return [3 /*break*/, 8];
+                        // pretend it was successful and just log the error
+                        WDOLogger.debug("Process canceled (but the request failed) - ".concat(error_1, "."));
+                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 7:
+                        _d.sent();
+                        return [3 /*break*/, 9];
+                    case 8: throw error_1; // rethrow
+                    case 9: return [3 /*break*/, 10];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Clear the stored data (without networking call). */
+    WDOBaseActivationService.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
-     * Creates service instance
+     * OTP resend request.
      *
-     * @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`.
+     * 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.
      */
-    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"; });
+    WDOBaseActivationService.prototype.resendOTP = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        WDOLogger.debug("Activation: resending OTP");
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
+                    case 1:
+                        pid = _a.sent();
+                        return [4 /*yield*/, this.verifyCanStartActivation()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.api.activationResendOTP(pid)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
     };
-    /* @internal */
-    WDOVerificationService.prototype.fetchActivationStatus = function () {
+    /**
+     * @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 result;
+            var pid;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.powerauth.fetchActivationStatus()];
+                    case 0:
+                        WDOLogger.debug("Activation: getting OTP from server (only for testing purposes)");
+                        return [4 /*yield*/, this.verifyHasActiveProcess()];
                     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();
+                        return [4 /*yield*/, this.api.activationGetOTP(pid, "ACTIVATION")];
+                    case 2: return [2 /*return*/, (_a.sent()).otpCode];
+                }
+            });
+        });
+    };
+    /**
+     * Activate the PowerAuth instance that was passed in the initializer.
+     *
+     * @param activationName Name of the activation. Usually something like John's iPhone or similar.
+     * @param otp OTP code received by the user (via SMS or email). Optional when not required.
+     * @return Promise resolved with activation result.
+     */
+    WDOBaseActivationService.prototype.activate = function (activationName, otp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid, code, result, 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 */
-    WDOVerificationService.prototype.changeAcceptLanguageImpl = function (language) {
-        this.api.networking.acceptLanguage = language;
+    WDOBaseActivationService.prototype.verifyCanStartActivation = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.powerauth.canStartActivation()];
+                    case 1:
+                        if (!!(_a.sent())) return [3 /*break*/, 3];
+                        WDOLogger.error("PowerAuth is already activated - Activation cannot be started/processed.");
+                        return [4 /*yield*/, this.setCachedProcessData(undefined)];
+                    case 2:
+                        _a.sent();
+                        throw new WDOError(exports.WDOErrorReason.powerauthAlreadyActivated, "PowerAuth is already activated");
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
     };
     /* @internal */
-    WDOVerificationService.prototype.getPAInstanceId = function () {
-        return this.powerauth.instanceId;
+    WDOBaseActivationService.prototype.verifyHasActiveProcess = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pid;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.processId()];
+                    case 1:
+                        pid = _a.sent();
+                        if (!pid) {
+                            WDOLogger.warn("Cannot proceed (processId not available).");
+                            throw new WDOError(exports.WDOErrorReason.processNotInProgress, "No active activation process");
+                        }
+                        return [2 /*return*/, pid];
+                }
+            });
+        });
     };
-    return WDOVerificationService;
-}(WDOBaseVerificationService));
+    return WDOBaseActivationService;
+}());
 
 /**
  * Copyright Wultra s.r.o.
@@ -2165,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.
@@ -2194,70 +2202,56 @@ var WDOBaseConfigurationService = /** @class */ (function () {
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-
-/** Service that provides configuration for the Wultra Digital Onboarding SDK. */
-var WDOConfigurationService = /** @class */ (function (_super) {
-    __extends(WDOConfigurationService, _super);
-    /**
-     * Creates service instance
-     *
-     * @param powerauth Configured PowerAuth instance.
-     * @param baseUrl Base URL of the Wultra Digital Onboarding server. Usually ending with `/enrollment-onboarding-server`.
-     */
-    function WDOConfigurationService(powerauth, baseUrl) {
-        var _this = _super.call(this) || this;
-        _this.api = new WDOApi(powerauth, baseUrl);
-        _this.powerauth = powerauth;
-        return _this;
-    }
-    return WDOConfigurationService;
-}(WDOBaseConfigurationService));
-
+WDOPlatform.cache = new WDOCordovaCache();
+WDOPlatform.networkingFactory = new WDONetworkingFactoryCordova();
+WDOPlatform.powerAuthFactory = new WDOPowerAuthFactoryCordova();
 /**
- * Copyright Wultra s.r.o.
+ * Service that can activate PowerAuth instance by user weak credentials (like his email, phone number or client ID) + optional SMS OTP.
  *
- * 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.
+ * When the PowerAuth is activated with this service, `WDOVerificationService.isVerificationRequired` will be `true`
+ * and you will need to verify the PowerAuth instance via `WDOVerificationService`.
  *
- * SPDX-License-Identifier: Apache-2.0
+ * 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 WDOCordovaCache = /** @class */ (function () {
-    function WDOCordovaCache() {
+var WDOActivationService = /** @class */ (function (_super) {
+    __extends(WDOActivationService, _super);
+    function WDOActivationService() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    WDOCordovaCache.prototype.set = function (key, value) {
-        if (value) {
-            return PowerAuthStorageUtils.setString(key, value, PowerAuthStorageType.SECURE);
-        }
-        else {
-            return PowerAuthStorageUtils.remove(key, PowerAuthStorageType.SECURE).then(function () { });
-        }
-    };
-    WDOCordovaCache.prototype.get = function (key) {
-        return PowerAuthStorageUtils.getString(key, PowerAuthStorageType.SECURE);
-    };
-    WDOCordovaCache.prototype.has = function (key) {
-        return PowerAuthStorageUtils.exists(key, PowerAuthStorageType.SECURE);
-    };
-    return WDOCordovaCache;
-}());
-
+    return WDOActivationService;
+}(WDOBaseActivationService));
 /**
- * Copyright Wultra s.r.o.
+ * Service that can verify previously activated PowerAuth instance.
  *
- * 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.
+ * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
  *
- * SPDX-License-Identifier: Apache-2.0
+ * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
  */
-WDODefaultCache.instance = new WDOCordovaCache();
+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);
+    function WDOConfigurationService() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return WDOConfigurationService;
+}(WDOBaseConfigurationService));
 
 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;