cordova-digital-onboarding 1.0.1 → 1.2.0

package/lib/index.d.ts

@@ -1,38 +1,3 @@
-/** Describes the state of documents that need to be uploaded to the server. */
-declare class WDOVerificationScanProcess {
-    /** All documents that need to be scanned. */
-    documents: WDOScannedDocument[];
-    /** Which document should be scanned next. `undefined` when all documents are uploaded and accepted. */
-    get nextDocumentToScan(): WDOScannedDocument | undefined;
-}
-/** Document that needs to be scanned during process. */
-declare class WDOScannedDocument {
-    /** Type of the document. */
-    type: WDODocumentType;
-    /** Upload state. */
-    get uploadState(): UploadState;
-    /** Sides of the document that were uploaded on the server. */
-    get sides(): Side[];
-}
-/** State of the document on the server. */
-declare enum UploadState {
-    /** The document was not uploaded yet. */
-    notUploaded = 0,
-    /** The document was accepted by the server. */
-    accepted = 1,
-    /** The document was rejected and needs to be re-uploaded. */
-    rejected = 2
-}
-/** Side of the uploaded document. */
-declare class Side {
-    /** Type of the side. */
-    type: WDODocumentSide;
-    /** ID on the server. Use this ID in case of an reupload */
-    serverId: string;
-    /** Upload state of the document */
-    uploadState: UploadState;
-}
-
 /** String that contains a Base64 encoded JPEG image */
 type Base64EncodedJPEG = string;
 /** Image of a document that can be sent to the backend for Identity Verification. */
@@ -85,13 +50,6 @@ declare enum WDODocumentType {
     /** Drivers license */
     driversLicense = "driversLicense"
 }
-/**
- * Available sides of the document
- *
- * Front and back for ID card.
- * For passport and drivers license front only.
- */
-declare function WDODocumentTypeSides(type: WDODocumentType): WDODocumentSide[];
 /** Side of the document */
 declare enum WDODocumentSide {
     /** Front side of a document. Usually the one with the picture.
@@ -103,138 +61,39 @@ declare enum WDODocumentSide {
     back = "back"
 }
 
-/** Status of the onboarding */
-declare enum WDOOnboardingStatus {
-    /** Activation part of the process is in progress */
-    activationInProgress = "ACTIVATION_IN_PROGRESS",
-    /** Verification part of the process is in progress */
-    verificationInProgress = "VERIFICATION_IN_PROGRESS",
-    /** Onboarding process has failed */
-    failed = "FAILED",
-    /** Onboarding process is completed */
-    finished = "FINISHED"
-}
-/** Configuration for a document */
-interface WDOConfigurationDocument {
-    /** Type of the document */
-    type: string;
-    /** Is the document mandatory */
-    mandatory: boolean;
-    /** Number of sides the document has */
-    sideCount: number;
-}
-/** Configuration for the onboarding process */
-interface WDOConfigurationResponse {
-    /** Is the onboarding process enabled */
-    enabled: boolean;
-    /** Is OTP required for the first part - identification/activation. */
-    otpForIdentification: boolean;
-    /** Is OTP required for the second part - identity verification. */
-    otpForIdentityVerification: boolean;
-    /** Documents required for identity verification. */
-    documents: {
-        /** Number of required documents */
-        requiredDocumentsCount: number;
-        /** List of documents */
-        items: Array<WDOConfigurationDocument>;
-    };
+/** Describes the state of documents that need to be uploaded to the server. */
+declare class WDOVerificationScanProcess {
+    /** All documents that need to be scanned. */
+    documents: WDOScannedDocument[];
+    /** Which document should be scanned next. `undefined` when all documents are uploaded and accepted. */
+    get nextDocumentToScan(): WDOScannedDocument | undefined;
 }
-
-/** Duck-typed PowerAuthActivationResult for WDO space */
-interface WDOPowerAuthActivationResult {
-    /** Decimalized fingerprint calculated from device's and server's public keys. */
-    activationFingerprint: string;
-    /** When available, contents of this object depends of your enrollment server configuration. */
-    customAttributes?: any;
+/** Document that needs to be scanned during process. */
+declare class WDOScannedDocument {
+    /** Type of the document. */
+    type: WDODocumentType;
+    /** Upload state. */
+    get uploadState(): UploadState;
+    /** Sides of the document that were uploaded on the server. */
+    get sides(): Side[];
 }
-/**
- * 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.
- */
-declare abstract class WDOBaseActivationService {
-    /**
-     * If the activation process is in progress.
-     *
-     * Note that even if this property is `true` it can be already discontinued on the server.
-     * Calling `status()` for example after the app is launched in this case is recommended.
-     */
-    get hasActiveProcess(): boolean;
-    /**
-     * 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).
-     */
-    changeAcceptLanguage(language: string): void;
-    /**
-     * Retrieves status of the onboarding activation.
-     *
-     * @return Promise resolved with onboarding status.
-     */
-    status(): Promise<WDOOnboardingStatus>;
-    /**
-     * 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.
-     */
-    start(credentials: any, processType?: string): Promise<void>;
-    /**
-     * 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.
-     */
-    cancel(forceCancel?: boolean): Promise<void>;
-    /** Clear the stored data (without networking call). */
-    clear(): void;
-    /**
-     * 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".
-     */
-    resendOTP(): Promise<void>;
-    /**
-     * Activate the PowerAuth instance that was passed in the initializer.
-     *
-     * @param activationName Name of the activation. Device name by default (usually something like John's iPhone or similar).
-     * @param otp OTP code received by the user (via SMS or email). Optional when not required.
-     * @return Promise resolved with activation result.
-     */
-    activate(activationName: string, otp?: string): Promise<WDOPowerAuthActivationResult>;
+/** State of the document on the server. */
+declare enum UploadState {
+    /** The document was not uploaded yet. */
+    notUploaded = 0,
+    /** The document was accepted by the server. */
+    accepted = 1,
+    /** The document was rejected and needs to be re-uploaded. */
+    rejected = 2
 }
-
-/**
- * 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.
- */
-declare class WDOActivationService extends WDOBaseActivationService {
-    /** PowerAuth instance */
-    readonly powerauth: PowerAuth;
-    /**
-     * 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`.
-     */
-    constructor(powerauth: PowerAuth, baseUrl: string);
+/** Side of the uploaded document. */
+declare class Side {
+    /** Type of the side. */
+    type: WDODocumentSide;
+    /** ID on the server. Use this ID in case of an reupload */
+    serverId: string;
+    /** Upload state of the document */
+    uploadState: UploadState;
 }
 
 /**
@@ -247,33 +106,23 @@ declare class WDOActivationService extends WDOBaseActivationService {
  * Usage:
  *
  * ```
- * const state = await verificationService.status();
+ * const state = await verificationService.status()
  * if (state.type === WDOVerificationStateType.scanDocument ) {
  *   // We are in the scan document state, access specific properties
- *   const process = state.process;
+ *   const process = state.process
  * }
  * ```
  */
-type WDOVerificationState = Intro | Consent | DocumentsToScanSelect | ScanDocument | Processing | PresenceCheck | Otp | Failed | EndState | Success;
+type WDOVerificationState = WDOIntroState | WDODocumentsToScanSelectState | WDOScanDocumentState | WDOProcessingState | WDOPresenceCheckState | WDOOtpState | WDOFinishActivation | WDOFailedState | WDOEndStateState | WDOSuccessState;
 /**
  * Show the verification introduction screen where the user can start the activation.
  *
- * The next step should be calling the `consentGet()`.
+ * The next step should be calling the `start`.
  */
-interface Intro {
+interface WDOIntroState {
     type: WDOVerificationStateType.intro;
-}
-/**
- * Show approve/cancel user consent.
- *
- * The content of the text depends on the server configuration and might be plain text or HTML.
- *
- * The next step should be calling the `consentApprove`.
- */
-interface Consent {
-    type: WDOVerificationStateType.consent;
-    /** Content of the consent text, which may be plain text or HTML depending on server configuration */
-    body: string;
+    /** Indicates whether the user consent is required to proceed */
+    consentRequired: boolean;
 }
 /**
  * Show document selection to the user. Which documents are available and how many
@@ -281,7 +130,7 @@ interface Consent {
  *
  * The next step should be calling the `documentsSetSelectedTypes`.
  */
-interface DocumentsToScanSelect {
+interface WDODocumentsToScanSelectState {
     type: WDOVerificationStateType.documentsToScanSelect;
 }
 /**
@@ -289,7 +138,7 @@ interface DocumentsToScanSelect {
  *
  * The next step should be calling the `documentsSubmit`.
  */
-interface ScanDocument {
+interface WDOScanDocumentState {
     type: WDOVerificationStateType.scanDocument;
     /** Scanning process that helps with the document scanning */
     process: WDOVerificationScanProcess;
@@ -299,7 +148,7 @@ interface ScanDocument {
  *
  * The next step should be calling the `status`.
  */
-interface Processing {
+interface WDOProcessingState {
     type: WDOVerificationStateType.processing;
     /** Reason for the current processing state */
     item: WDOStatusCheckReason;
@@ -311,7 +160,7 @@ interface Processing {
  * 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.
  */
-interface PresenceCheck {
+interface WDOPresenceCheckState {
     type: WDOVerificationStateType.presenceCheck;
 }
 /**
@@ -320,18 +169,26 @@ interface PresenceCheck {
  * The next step should be calling the `verifyOTP` with user-entered OTP.
  * The OTP is usually SMS or email.
  */
-interface Otp {
+interface WDOOtpState {
     type: WDOVerificationStateType.otp;
     /** Number of remaining attempts to enter the correct OTP */
     remainingAttempts?: number;
 }
+/**
+ * Show "finish activation" with PIN prompt screen.
+ *
+ * The next step should be calling the `finishActivation` with user entered PIN.
+ */
+interface WDOFinishActivation {
+    type: WDOVerificationStateType.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.
  */
-interface Failed {
+interface WDOFailedState {
     type: WDOVerificationStateType.failed;
 }
 /**
@@ -339,7 +196,7 @@ interface Failed {
  *
  * The next step should be calling the `PowerAuth.removeActivationLocal()` and starting activation from scratch.
  */
-interface EndState {
+interface WDOEndStateState {
     type: WDOVerificationStateType.endState;
     /** Reason for the end state */
     reason: WDOEndStateReason;
@@ -347,7 +204,7 @@ interface EndState {
 /**
  * Verification was successfully ended. Continue into your app flow.
  */
-interface Success {
+interface WDOSuccessState {
     type: WDOVerificationStateType.success;
 }
 /** Types of the verification state */
@@ -355,17 +212,9 @@ declare enum WDOVerificationStateType {
     /**
      * Show the verification introduction screen where the user can start the activation.
      *
-     * The next step should be calling the `consentGet()`.
+     * The next step should be calling the `start()`.
      */
     intro = "intro",
-    /**
-     * Show approve/cancel user consent.
-     *
-     * The content of the text depends on the server configuration and might be plain text or HTML.
-     *
-     * The next step should be calling the `consentApprove`.
-     */
-    consent = "consent",
     /**
      * Show document selection to the user. Which documents are available and how many
      * can the user select is up to your backend configuration.
@@ -400,6 +249,12 @@ declare enum WDOVerificationStateType {
      * The OTP is usually SMS or email.
      */
     otp = "otp",
+    /**
+     * Show "finish activation" with PIN prompt screen.
+     *
+     * The next step should be calling the `finishActivation` with user entered PIN.
+     */
+    finishActivation = "finishActivation",
     /**
      * Verification failed and can be restarted
      *
@@ -450,21 +305,40 @@ declare enum WDOStatusCheckReason {
     clientAccepted = "clientAccepted",
     verifyingPresence = "verifyingPresence"
 }
-
-/**
- * ######################################
- * This file contains duck-typed representation of PowerAuthActivationStatus
- * to avoid direct dependency on PowerAuth types in the shared library.
- * ######################################
- */
+/** Internal multiplatform PowerAuth representation */
+interface WDOPowerAuth {
+    fetchActivationStatus(): Promise<WDOPowerAuthActivationStatus>;
+    validatePassword(password: WDOPowerAuthPassword | string): Promise<void>;
+    createActivation(activation: WDOPowerAuthActivation): Promise<WDOPowerAuthCreateActivationResult>;
+    persistActivation(authentication: WDOPowerAuthAuthentication): Promise<void>;
+    canStartActivation(): Promise<boolean>;
+    removeActivationLocal(): Promise<void>;
+    get instanceId(): string;
+}
+/** Internal multiplatform PowerAuthPassword representation */
+interface WDOPowerAuthPassword {
+    clear(): Promise<void>;
+}
+/** Internal multiplatform WDOPowerAuthActivation representation */
+interface WDOPowerAuthActivation {
+}
+/** Internal multiplatform WDOPowerAuthAuthentication representation */
+interface WDOPowerAuthAuthentication {
+}
+/** Internal multiplatform WDOPowerAuthCreateActivationResult representation */
+interface WDOPowerAuthCreateActivationResult {
+    activationFingerprint: string;
+    customAttributes?: any;
+}
 /**
+ *
  * The `WDOPowerAuthActivationStatus` object represents complete status of the activation.
  */
 interface WDOPowerAuthActivationStatus {
     /**
      * State of the activation.
      */
-    state: WDOPowerAuthActivationState;
+    state: "CREATED" | "PENDING_COMMIT" | "ACTIVE" | "BLOCKED" | "REMOVED" | "DEADLOCK";
     /**
      * Number of failed authentication attempts in a row.
      */
@@ -482,38 +356,6 @@ interface WDOPowerAuthActivationStatus {
      */
     customObject?: any;
 }
-/**
- * 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.
- */
-declare enum WDOPowerAuthActivationState {
-    /**
-     * The activation is just created.
-     */
-    CREATED = "CREATED",
-    /**
-     * The activation is not completed yet on the server.
-     */
-    PENDING_COMMIT = "PENDING_COMMIT",
-    /**
-     * The shared secure context is valid and active.
-     */
-    ACTIVE = "ACTIVE",
-    /**
-     * The activation is blocked.
-     */
-    BLOCKED = "BLOCKED",
-    /**
-     * The activation doesn't exist anymore.
-     */
-    REMOVED = "REMOVED",
-    /**
-     * The activation is technically blocked. You cannot use it anymore
-     * for the signature calculations.
-     */
-    DEADLOCK = "DEADLOCK"
-}
 
 /**
  * Listener of the Verification Service that can listen on Verification Status and PowerAuth Status changes.
@@ -525,9 +367,18 @@ interface WDOVerificationServiceListener {
      *  Note that this happens only when error is returned in some of the Verification endpoints and this error indicates PowerAuth status change. For
      * example when the service finds out during the API call that the PowerAuth activation was removed or blocked on the server
      */
-    powerAuthActivationStatusChanged(sender: WDOBaseVerificationService, status: WDOPowerAuthActivationStatus): void;
+    powerAuthActivationStatusChanged(senderService: any, status: WDOPowerAuthActivationStatus): void;
     /** Called when state of the verification has changed. */
-    verificationStatusChanged(sender: WDOBaseVerificationService, status: WDOVerificationState): void;
+    verificationStatusChanged(senderService: any, status: WDOVerificationState): void;
+}
+/** Possible results of the user consent. */
+declare enum WDOConsentResponse {
+    /** User approved the consent. */
+    approved = 0,
+    /** User declined the consent. */
+    declined = 1,
+    /** Consent is not required. */
+    notRequired = 2
 }
 /**
  * Service that can verify previously activated PowerAuth instance.
@@ -537,7 +388,19 @@ interface WDOVerificationServiceListener {
  *
  * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
  */
-declare abstract class WDOBaseVerificationService {
+declare abstract class WDOBaseVerificationService<TPowerAuth extends WDOPowerAuth, TPowerAuthPassword extends WDOPowerAuthPassword> {
+    /** Checks if verification is required based on PowerAuth activation status */
+    protected static isVerificationRequiredInternal(paStatus: WDOPowerAuthActivationStatus): boolean;
+    /** PowerAuth instance */
+    readonly powerauth: TPowerAuth;
+    private readonly 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`.
+     */
+    constructor(powerauth: TPowerAuth, baseUrl: string);
     /**
      * Accept language for the outgoing requests headers.
      * Default value is "en".
@@ -562,11 +425,13 @@ declare abstract class WDOBaseVerificationService {
      *
      * Consent text explains how the service will handle his document photos or selfie scans.
      */
-    consentGet(): Promise<WDOVerificationState>;
+    consentGet(): Promise<string>;
     /**
-     * Approves the consent for this process and starts the activation.
+     * Start the identity verification after user approved the consent (if required)
+     *
+     * @param consentApprovedByUser Response of the user to the consent. The hint can be obtained in the `status()` call (`consentRequired` property when the result is `intro`).
      */
-    consentApprove(): Promise<WDOVerificationState>;
+    start(consentApprovedByUser: WDOConsentResponse): Promise<WDOVerificationState>;
     /**
      * Get the token for the document scanning SDK, when required.
      *
@@ -574,7 +439,10 @@ declare abstract class WDOBaseVerificationService {
      *
      * @param challenge Optional challenge provided by the scanning SDK.
      */
-    documentsInitSDK(challenge?: string): Promise<any>;
+    documentsInitSDK(challenge?: string): Promise<{
+        blinkIDKey?: string;
+        zenIDToken?: string;
+    }>;
     /**
      * Set which documents will be scanned.
      *
@@ -595,7 +463,9 @@ declare abstract class WDOBaseVerificationService {
     /**
      * Initiates the presence check. This returns attributes that are needed to start the 3rd party SDK (if needed).
      */
-    presenceCheckInit(): Promise<any>;
+    presenceCheckInit(): Promise<{
+        iProovVerificationToken?: string;
+    }>;
     /**
      * Call when presence check was finished in the 3rd party SDK.
      */
@@ -615,6 +485,26 @@ declare abstract class WDOBaseVerificationService {
      * @param otp OTP that user obtained via other channel (usually SMS or email).
      */
     verifyOTP(otp: string): Promise<WDOVerificationState>;
+    /**
+     * 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.
+     */
+    finishActivation(newPowerAuthInstance: TPowerAuth, newActivationName: string, newPassword: TPowerAuthPassword, validatePassword: boolean, userIdentification?: any): Promise<WDOVerificationState>;
     /**
      * Request OTP resend.
      *
@@ -623,69 +513,236 @@ declare abstract class WDOBaseVerificationService {
     resendOTP(): Promise<void>;
 }
 
+/** Log levels for Wultra Digital Onboarding. */
+declare enum WDOLogLevel {
+    NONE = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4
+}
+/** Simple logger utility for Wultra Digital Onboarding SDK. */
+declare class WDOLogger {
+    /** Current log level. Messages with a level higher than this will not be logged. */
+    static logLevel: WDOLogLevel;
+    /** Listener for custom logging implementation */
+    static listener: WDOLoggerListener | null;
+}
+/** Log listener for your custom logging implementation */
+interface WDOLoggerListener {
+    log(level: WDOLogLevel, message: string): void;
+}
+
+/** Status of the onboarding */
+declare enum WDOOnboardingStatus {
+    /** Activation part of the process is in progress */
+    activationInProgress = "ACTIVATION_IN_PROGRESS",
+    /** Verification part of the process is in progress */
+    verificationInProgress = "VERIFICATION_IN_PROGRESS",
+    /** Onboarding process has failed */
+    failed = "FAILED",
+    /** Onboarding process is completed */
+    finished = "FINISHED"
+}
+/** Configuration for a document */
+interface WDOConfigurationDocument {
+    /** Type of the document */
+    type: string;
+    /** Number of sides the document has */
+    sideCount: number;
+}
+/** Group of documents in the configuration */
+interface WDOConfigurationDocumentGroup {
+    /** Number of required documents in the group */
+    requiredDocumentsCount: number;
+    /** Documents in the group */
+    items: Array<WDOConfigurationDocument>;
+}
+/** Configuration for the onboarding process */
+interface WDOConfigurationResponse {
+    /** Is the onboarding process enabled */
+    enabled: boolean;
+    /** Is OTP required for the first part - identification/activation. */
+    otpForIdentification: boolean;
+    /** Is OTP required for the second part - identity verification. */
+    otpForIdentityVerification: boolean;
+    /** Documents required for identity verification. */
+    documents: {
+        /** Number of total required documents */
+        totalRequiredDocumentsCount: number;
+        /** Groups of documents */
+        groups: Array<WDOConfigurationDocumentGroup>;
+    };
+}
+
+/** Represent error thrown from a WDO library */
+declare class WDOError {
+    /** Reason for the error */
+    readonly reason: WDOErrorReason;
+    /** Error message */
+    readonly message: string;
+    /** Additional info about the error (eg. original error object) */
+    readonly additionalInfo?: any;
+    /** Helper to identify this object as a WDOError */
+    readonly isWdoError = true;
+    /**
+     * Whether retrying OTP is allowed based on remaining attempts.
+     *
+     * This may be filled only when the error reason is `WDOErrorReason.activationFailed`.
+     */
+    get allowOnboardingOtpRetry(): boolean;
+    /**
+     * Number of remaining OTP attempts during onboarding
+     *
+     * This may be filled only when the error reason is `WDOErrorReason.activationFailed`.
+     */
+    get onboardingOtpRemainingAttempts(): number | undefined;
+}
+/** Reasons for WDO errors */
+declare enum WDOErrorReason {
+    /** Network error occurred */
+    networkError = "NETWORK_ERROR",
+    /** Activation failed */
+    activationFailed = "ACTIVATION_FAILED",
+    /** Process is already in progress - happens when start() is called twice */
+    processAlreadyInProgress = "PROCESS_ALREADY_IN_PROGRESS",
+    /** No process is in progress - happens when an operation requires an active process */
+    processNotInProgress = "PROCESS_NOT_IN_PROGRESS",
+    /** The PowerAuth instance is already activated when trying to activate it again */
+    powerauthAlreadyActivated = "POWERAUTH_ALREADY_ACTIVATED",
+    /** The PowerAuth instance is not configured properly */
+    powerAuthNotConfigured = "POWERAUTH_NOT_CONFIGURED",
+    /** The PowerAuth instance is not activated when trying to use it */
+    powerauthNotActivated = "POWERAUTH_NOT_ACTIVATED",
+    /** OTP verification failed */
+    otpFailed = "OTP_FAILED",
+    /** Invalid parameter */
+    invalidParameter = "INVALID_PARAMETER"
+}
+
 /**
- * Service that can verify previously activated PowerAuth instance.
+ * Service that can activate PowerAuth instance by user weak credentials (like his email, phone number or client ID) + optional SMS OTP.
  *
- * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
+ * 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.
  */
-declare class WDOVerificationService extends WDOBaseVerificationService {
+declare abstract class WDOBaseActivationService<TPowerAuth extends WDOPowerAuth> {
     /** PowerAuth instance */
-    readonly powerauth: PowerAuth;
-    /** Checks if verification is required based on PowerAuth activation status */
-    static isVerificationRequired(paStatus: PowerAuthActivationStatus): boolean;
+    readonly powerauth: TPowerAuth;
     /**
      * 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`.
      */
-    constructor(powerauth: PowerAuth, baseUrl: string);
-}
-
-/** Service that provides configuration for the Wultra Digital Onboarding SDK. */
-declare abstract class WDOBaseConfigurationService {
+    constructor(powerauth: TPowerAuth, baseUrl: string);
     /**
-     * Fetches configuration for the given process type from the server.
+     * If the activation process is in progress.
      *
-     * @param processType Type of the process for which to fetch configuration.
-     * @returns Configuration response from the server.
+     * 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.
      */
-    getConfiguration(processType: string): Promise<WDOConfigurationResponse>;
+    hasActiveProcess(): Promise<boolean>;
+    /**
+     * 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).
+     */
+    changeAcceptLanguage(language: string): void;
+    /**
+     * Retrieves status of the onboarding activation.
+     *
+     * @return Promise resolved with onboarding status.
+     */
+    status(): Promise<WDOOnboardingStatus>;
+    /**
+     * 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.
+     */
+    start(credentials: any, processType?: string): Promise<void>;
+    /**
+     * 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.
+     */
+    cancel(forceCancel?: boolean): Promise<void>;
+    /** Clear the stored data (without networking call). */
+    clear(): Promise<void>;
+    /**
+     * 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".
+     * 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.
+     */
+    resendOTP(): Promise<void>;
+    /**
+     * 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.
+     */
+    activate(activationName: string, otp?: string): Promise<WDOPowerAuthCreateActivationResult>;
 }
 
 /** Service that provides configuration for the Wultra Digital Onboarding SDK. */
-declare class WDOConfigurationService extends WDOBaseConfigurationService {
+declare abstract class WDOBaseConfigurationService<TPowerAuth extends WDOPowerAuth> {
     /** PowerAuth instance */
-    readonly powerauth: PowerAuth;
+    readonly powerauth: TPowerAuth;
     /**
      * Creates service instance
      *
      * @param powerauth Configured PowerAuth instance.
      * @param baseUrl Base URL of the Wultra Digital Onboarding server. Usually ending with `/enrollment-onboarding-server`.
      */
-    constructor(powerauth: PowerAuth, baseUrl: string);
+    constructor(powerauth: TPowerAuth, baseUrl: string);
+    /**
+     * Fetches configuration for the given process type from the server.
+     *
+     * @param processType Type of the process for which to fetch configuration.
+     * @returns Configuration response from the server.
+     */
+    getConfiguration(processType: string): Promise<WDOConfigurationResponse>;
 }
 
-/** Log levels for Wultra Digital Onboarding. */
-declare enum WDOLogLevel {
-    NONE = 0,
-    ERROR = 1,
-    WARN = 2,
-    INFO = 3,
-    DEBUG = 4
+/**
+ * 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.
+ */
+declare class WDOActivationService extends WDOBaseActivationService<PowerAuth> {
 }
-/** Simple logger utility for Wultra Digital Onboarding SDK. */
-declare class WDOLogger {
-    /** Current log level. Messages with a level higher than this will not be logged. */
-    static logLevel: WDOLogLevel;
-    /** Listener for custom logging implementation */
-    static listener: WDOLoggerListener | null;
+/**
+ * Service that can verify previously activated PowerAuth instance.
+ *
+ * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
+ *
+ * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
+ */
+declare class WDOVerificationService extends WDOBaseVerificationService<PowerAuth, PowerAuthPassword> {
+    /** Checks if verification is required based on PowerAuth activation status */
+    static isVerificationRequired(paStatus: PowerAuthActivationStatus): boolean;
 }
-/** Log listener for your custom logging implementation */
-interface WDOLoggerListener {
-    log(level: WDOLogLevel, message: string): void;
+/** Service that provides configuration for the Wultra Digital Onboarding SDK. */
+declare class WDOConfigurationService extends WDOBaseConfigurationService<PowerAuth> {
 }
-export { Side, UploadState, WDOActivationService, WDOConfigurationService, WDODocumentFile, WDODocumentSide, WDODocumentType, WDODocumentTypeSides, WDOEndStateReason, WDOLogLevel, WDOLogger, WDOScannedDocument, WDOStatusCheckReason, WDOVerificationScanProcess, WDOVerificationService, WDOVerificationStateType };
-export type { Base64EncodedJPEG, WDOLoggerListener, WDOVerificationState };
+export { Side, UploadState, WDOActivationService, WDOConfigurationService, WDOConsentResponse, WDODocumentFile, WDODocumentSide, WDODocumentType, WDOEndStateReason, WDOError, WDOErrorReason, WDOLogLevel, WDOLogger, WDOOnboardingStatus, WDOScannedDocument, WDOStatusCheckReason, WDOVerificationScanProcess, WDOVerificationService, WDOVerificationStateType };
+export type { Base64EncodedJPEG, WDOConfigurationDocument, WDOConfigurationDocumentGroup, WDOConfigurationResponse, WDODocumentsToScanSelectState, WDOEndStateState, WDOFailedState, WDOFinishActivation, WDOIntroState, WDOLoggerListener, WDOOtpState, WDOPresenceCheckState, WDOProcessingState, WDOScanDocumentState, WDOSuccessState, WDOVerificationServiceListener, WDOVerificationState };