cordova-digital-onboarding 1.0.0 → 1.1.0

package/lib/index.d.ts

@@ -0,0 +1,877 @@
+/** For request that needs to identify the current process. */
+interface WDOProcessRequest {
+    processId: string;
+}
+/** Onboarding process response */
+interface WDOProcessResponse {
+    /** ID of the process */
+    processId: string;
+    /** Status of the process */
+    onboardingStatus: WDOOnboardingStatus;
+    /**
+     * Activation code used during the activation process.
+     * If not present, the activation is created later on in the onboarding process.
+     */
+    activationCode?: string;
+}
+/** 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"
+}
+interface WDOIdentityStatusResponse {
+    processId: string;
+    identityVerificationStatus: WDOIdentityVerificationStatus;
+    identityVerificationPhase?: WDOIdentityVerificationPhase;
+    config: WDOIdentityConfig;
+    consentRequired: boolean;
+}
+/** Configuration for identity verification */
+interface WDOIdentityConfig {
+    /** Period after which the OTP can be resent, in seconds */
+    otpResendPeriodSeconds: number;
+}
+/** Status of the current identity verification */
+declare enum WDOIdentityVerificationStatus {
+    /** Identity verification is waiting for initialization */
+    notInitialized = "NOT_INITIALIZED",
+    /** All submitted documents are waiting for verification */
+    verificationPending = "VERIFICATION_PENDING",
+    /** Identity verification is in progress */
+    inProgress = "IN_PROGRESS",
+    /** Identity verification was successfully completed */
+    accepted = "ACCEPTED",
+    /** Identity verification has failed, an error occurred */
+    failed = "FAILED",
+    /** Identity verification was rejected */
+    rejected = "REJECTED"
+}
+/** Phase of the current identity verification */
+declare enum WDOIdentityVerificationPhase {
+    /** Document upload is in progress */
+    documentUpload = "DOCUMENT_UPLOAD",
+    /** Presence check is in progress */
+    presenceCheck = "PRESENCE_CHECK",
+    /** Backend is verifying documents */
+    clientEvaluation = "CLIENT_EVALUATION",
+    /** Document verification is in progress */
+    documentVerification = "DOCUMENT_VERIFICATION",
+    /** Cross check on documents is in progress */
+    documentVerificationFinal = "DOCUMENT_VERIFICATION_FINAL",
+    /** OTP verification needed */
+    otp = "OTP_VERIFICATION",
+    /** Completed */
+    completed = "COMPLETED"
+}
+/** Types of available documents */
+declare enum WDODocumentSubmitFileType {
+    /** National ID card */
+    idCard = "ID_CARD",
+    /** Passport */
+    passport = "PASSPORT",
+    /** Driving license */
+    driversLicense = "DRIVING_LICENSE",
+    /** Selfie photo */
+    selfiePhoto = "SELFIE_PHOTO"
+}
+/** Side of the file */
+declare enum WDODocumentSubmitFileSide {
+    /** Front side of an document. Usually the one with the picture */
+    front = "FRONT",
+    /** Back side of an document */
+    back = "BACK"
+}
+/** Submitted document metadata */
+interface WDODocument {
+    /** Name of the file (with path within the submit ZIP file). */
+    filename: string;
+    /** Unique ID of the file */
+    id: string;
+    /** Type of the file */
+    type: WDODocumentSubmitFileType;
+    /** Side of the file */
+    side: WDODocumentSubmitFileSide;
+    /** Status of the processing */
+    status: WDODocumentStatus;
+    /** Possible errors */
+    errors?: string[];
+}
+/** Status of the document */
+declare enum WDODocumentStatus {
+    /** Document was accepted */
+    accepted = "ACCEPTED",
+    /** Document is being uploaded to the verification system by the backend */
+    uploadInProgress = "UPLOAD_IN_PROGRESS",
+    /** Document are being processed */
+    inProgress = "IN_PROGRESS",
+    /** Document is pending verification */
+    verificationPending = "VERIFICATION_PENDING",
+    /** Document is being verified */
+    verificationInProgress = "VERIFICATION_IN_PROGRESS",
+    /** Document was rejected */
+    rejected = "REJECTED",
+    /** Verification of the document failed */
+    failed = "FAILED"
+}
+/** Metadata for file inside ZIP (in `DocumentSubmitRequest.data`). */
+interface WDODocumentSubmitFile {
+    /** Name of the file (with path) */
+    filename: string;
+    /** Type of the document */
+    type: WDODocumentSubmitFileType;
+    /** Side of the document (for example front side of the ID card) */
+    side: WDODocumentSubmitFileSide;
+    /** Original document ID in case of re-upload */
+    originalDocumentId?: string;
+    /** Base64 encoded data image. */
+    data: Base64URLString;
+}
+/** Status of the documents */
+interface WDODocumentStatusResponse {
+    /** Overall status */
+    status: WDODocumentStatus;
+    /** Status for each document. */
+    documents: WDODocument[];
+}
+/** Response of the OTP verify */
+interface WDOVerifyOTPResponse {
+    /** ID of the process */
+    processId: string;
+    /** Current onboarding status */
+    onboardingStatus: WDOOnboardingStatus;
+    /** Was OTP verified? */
+    verified: boolean;
+    /** Is OTP expired */
+    expired: boolean;
+    /** How many attempts are remaining */
+    remainingAttempts: number;
+}
+/** 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>;
+    };
+}
+
+/** 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;
+}
+/**
+ * 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.
+     */
+    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".
+     */
+    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<WDOPowerAuthActivationResult>;
+}
+
+/**
+ * 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);
+}
+
+/** 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. */
+declare class WDODocumentFile {
+    /** Raw data to upload. Make sure that the data aren't too big, hundreds of kbs should be enough. */
+    data: Base64EncodedJPEG;
+    /**
+     * Image signature.
+     *
+     * Optional, use only when the scan SDK supports this.
+     */
+    dataSignature: string | undefined;
+    /** Type of the document. */
+    type: WDODocumentType;
+    /** Side of the document (`front` if the document is one-sided or only one side is expected). */
+    side: WDODocumentSide;
+    /**
+     * For image reuploading when the previous file of the same document was rejected.
+     *
+     * Without specifying this value, the document side won't be overwritten.
+     */
+    originalDocumentId: string | undefined;
+    /**
+     * Create the document file from an image that can be sent to the backend for Identity Verification.
+     *
+     * @param scannedDocument Document to upload.
+     * @param side The side of the document that the image captures.
+     * @param data Raw image data. Make sure that the data aren't too big, hundreds of kbs should be enough.
+     * @param dataSignature Signature of the image data. Optional, use only when the scan SDK supports this. `undefined` by default.
+     * @returns Document file to upload.
+     */
+    static fromScannedDocument(scannedDocument: WDOScannedDocument, side: WDODocumentSide, data: Base64EncodedJPEG, dataSignature?: string): WDODocumentFile;
+    /**
+     * Image of a document that can be sent to the backend for Identity Verification.
+     *
+     * @param data Raw image data. Make sure that the data aren't too big, hundreds of kbs should be enough.
+     * @param type Type of the document.
+     * @param side The side of the document that the image captures.
+     * @param originalDocumentId Original document ID In case of a reupload. If you've previously uploaded this type and side and won't specify the previous ID, the image won't be overwritten.
+     * @param dataSignature Signature of the image data. Optional, use only when the scan SDK supports this. `undefined` by default.
+     */
+    constructor(data: Base64EncodedJPEG, type: WDODocumentType, side: WDODocumentSide, originalDocumentId?: string, dataSignature?: string);
+}
+/** Type of the document. */
+declare enum WDODocumentType {
+    /** National ID card */
+    idCard = "idCard",
+    /** Passport */
+    passport = "passport",
+    /** 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.
+     *
+     * When a document has more than one side but only one side is used (for example passport), then such side is considered to be front.
+     */
+    front = "front",
+    /** Back side of a document */
+    back = "back"
+}
+/** Converts WDODocumentType to WDODocumentSubmitFileType */
+declare function WDODocumentTypeToSubmitType(type: WDODocumentType): WDODocumentSubmitFileType;
+/** Converts WDODocumentSide to DocumentSubmitFileSide */
+declare function WDOCreateDocumentSubmitFileSide(side: WDODocumentSide): WDODocumentSubmitFileSide;
+
+/** 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;
+}
+
+/**
+ * State which should be presented to the user.
+ * Each state represents a separate screen UI that should be presented to the user.
+ *
+ * This type is an "tagged union" type, where each interface has a `type` property
+ * that uniquely identifies the state type.
+ *
+ * Usage:
+ *
+ * ```
+ * const state = await verificationService.status();
+ * if (state.type === WDOVerificationStateType.scanDocument ) {
+ *   // We are in the scan document state, access specific properties
+ *   const process = state.process;
+ * }
+ * ```
+ */
+type WDOVerificationState = WDOIntroState | WDODocumentsToScanSelectState | WDOScanDocumentState | WDOProcessingState | WDOPresenceCheckState | WDOOtpState | WDOFailedState | WDOEndStateState | WDOSuccessState;
+/**
+ * Show the verification introduction screen where the user can start the activation.
+ *
+ * The next step should be calling the `start`.
+ */
+interface WDOIntroState {
+    type: WDOVerificationStateType.intro;
+    /** Indicates whether the user consent is required to proceed */
+    consentRequired: boolean;
+}
+/**
+ * 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`.
+ */
+interface WDODocumentsToScanSelectState {
+    type: WDOVerificationStateType.documentsToScanSelect;
+}
+/**
+ * User should scan documents - display UI for the user to scan all necessary documents.
+ *
+ * The next step should be calling the `documentsSubmit`.
+ */
+interface WDOScanDocumentState {
+    type: WDOVerificationStateType.scanDocument;
+    /** Scanning process that helps with the document scanning */
+    process: WDOVerificationScanProcess;
+}
+/**
+ * The system is processing data - show loading with text hint from provided `WDOStatusCheckReason`.
+ *
+ * The next step should be calling the `status`.
+ */
+interface WDOProcessingState {
+    type: WDOVerificationStateType.processing;
+    /** Reason for the current processing state */
+    item: WDOStatusCheckReason;
+}
+/**
+ * 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.
+ */
+interface WDOPresenceCheckState {
+    type: WDOVerificationStateType.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.
+ */
+interface WDOOtpState {
+    type: WDOVerificationStateType.otp;
+    /** Number of remaining attempts to enter the correct OTP */
+    remainingAttempts?: number;
+}
+/**
+ * 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 WDOFailedState {
+    type: WDOVerificationStateType.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.
+ */
+interface WDOEndStateState {
+    type: WDOVerificationStateType.endState;
+    /** Reason for the end state */
+    reason: WDOEndStateReason;
+}
+/**
+ * Verification was successfully ended. Continue into your app flow.
+ */
+interface WDOSuccessState {
+    type: WDOVerificationStateType.success;
+}
+/** Types of the verification state */
+declare enum WDOVerificationStateType {
+    /**
+     * Show the verification introduction screen where the user can start the activation.
+     *
+     * The next step should be calling the `start()`.
+     */
+    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`.
+     */
+    documentsToScanSelect = "documentsToScanSelect",
+    /**
+     * User should scan documents - display UI for the user to scan all necessary documents.
+     *
+     * The next step should be calling the `documentsSubmit`.
+     */
+    scanDocument = "scanDocument",
+    /**
+     * The system is processing data - show loading with text hint from provided `WDOStatusCheckReason`.
+     *
+     * The next step should be calling the `status`.
+     */
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    endState = "endState",
+    /**
+     * Verification was successfully ended. Continue into your app flow.
+     */
+    success = "success"
+}
+/** The reason why the process ended in a non-recoverable state. */
+declare enum 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.
+     */
+    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.
+     */
+    limitReached = "limitReached",
+    /** An unknown reason. */
+    other = "other"
+}
+/**
+ * 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.
+ */
+declare enum WDOStatusCheckReason {
+    unknown = "unknown",
+    documentUpload = "documentUpload",
+    documentVerification = "documentVerification",
+    documentAccepted = "documentAccepted",
+    documentsCrossVerification = "documentsCrossVerification",
+    clientVerification = "clientVerification",
+    clientAccepted = "clientAccepted",
+    verifyingPresence = "verifyingPresence"
+}
+
+/**
+ * ######################################
+ * This file contains duck-typed representation of PowerAuthActivationStatus
+ * to avoid direct dependency on PowerAuth types in the shared library.
+ * ######################################
+ */
+/**
+ * The `WDOPowerAuthActivationStatus` object represents complete status of the activation.
+ */
+interface WDOPowerAuthActivationStatus {
+    /**
+     * State of the activation.
+     */
+    state: WDOPowerAuthActivationState;
+    /**
+     * Number of failed authentication attempts in a row.
+     */
+    failCount: number;
+    /**
+     * Maximum number of allowed failed authentication attempts in a row.
+     */
+    maxFailCount: number;
+    /**
+     * Contains `(maxFailCount - failCount)` if state is `ACTIVE`, otherwise 0.
+     */
+    remainingAttempts: number;
+    /**
+     * Contains custom object returned from the server. The value is optional and PowerAuth Application Server must support this custom object.
+     */
+    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.
+ */
+interface WDOVerificationServiceListener {
+    /**
+     * Called when PowerAuth activation status changed.
+     *
+     *  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;
+    /** Called when state of the verification has changed. */
+    verificationStatusChanged(sender: WDOBaseVerificationService, 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.
+ *
+ * When PowerAuth instance was activated with weak credentials via `WDOActivationService`, user needs to verify his genuine presence.
+ * This can be confirmed in the `WDOVerificationService.isVerificationRequired` which will be `true`.
+ *
+ * This service operates against Wultra Onboarding server (usually ending with `/enrollment-onboarding-server`) and you need to configure networking service with the right URL.
+ */
+declare abstract class WDOBaseVerificationService {
+    /**
+     * 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;
+    /** Time in seconds that user needs to wait between OTP resend calls */
+    get otpResendPeriodSeconds(): number | undefined;
+    /**
+     * Listener that retrieves information about the verification and activation changes.
+     */
+    listener?: WDOVerificationServiceListener;
+    /**
+     * Status of the verification.
+     */
+    status(): Promise<WDOVerificationState>;
+    /**
+     * Returns consent text for user to approve. The content of the text depends on the server configuration and might be plain text or HTML.
+     *
+     * Consent text explains how the service will handle his document photos or selfie scans.
+     */
+    consentGet(): Promise<string>;
+    /**
+     * 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`).
+     */
+    start(consentApprovedByUser: WDOConsentResponse): Promise<WDOVerificationState>;
+    /**
+     * Get the token for the document scanning SDK, when required.
+     *
+     * This is needed for example for ZenID or BlinkID provider.
+     *
+     * @param challenge Optional challenge provided by the scanning SDK.
+     */
+    documentsInitSDK(challenge?: string): Promise<{
+        blinkIDKey?: string;
+        zenIDToken?: string;
+    }>;
+    /**
+     * Set which documents will be scanned.
+     *
+     * Note that this needs to be in sync what server expects based on the configuration.
+     *
+     * @param types Types of documents to scan.
+     */
+    documentsSetSelectedTypes(types: WDODocumentType[]): Promise<WDOVerificationState>;
+    /**
+     * Upload document files to the server. The order of the documents is up to you.
+     * Make sure that uploaded document are reasonable size so you're not uploading large files.
+     *
+     * If you're uploading the same document file again, you need to include the `originalDocumentId` otherwise it will be rejected by the server.
+     *
+     * @param files Document files to upload.
+     */
+    documentsSubmit(files: WDODocumentFile[]): Promise<WDOVerificationState>;
+    /**
+     * Initiates the presence check. This returns attributes that are needed to start the 3rd party SDK (if needed).
+     */
+    presenceCheckInit(): Promise<{
+        iProovVerificationToken?: string;
+    }>;
+    /**
+     * Call when presence check was finished in the 3rd party SDK.
+     */
+    presenceCheckSubmit(): Promise<WDOVerificationState>;
+    /**
+     * Verification restart. When sucessfully called, intro screen should be presented.
+     */
+    restartVerification(): Promise<WDOVerificationState>;
+    /**
+     * Cancel the whole activation/verification. After this it's no longer possible to call
+     * any API of this library and PowerAuth activation should be removed and activation started again.
+     */
+    cancelWholeProcess(): Promise<void>;
+    /**
+     * Verify OTP that user entered as a last step of the verification.
+     *
+     * @param otp OTP that user obtained via other channel (usually SMS or email).
+     */
+    verifyOTP(otp: string): Promise<WDOVerificationState>;
+    /**
+     * Request OTP resend.
+     *
+     * Since SMS or emails can fail to deliver, use this to send the OTP again.
+     */
+    resendOTP(): Promise<void>;
+}
+
+/**
+ * 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 instance */
+    readonly powerauth: PowerAuth;
+    /** Checks if verification is required based on PowerAuth activation status */
+    static isVerificationRequired(paStatus: PowerAuthActivationStatus): boolean;
+    /**
+     * 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 {
+    /**
+     * 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>;
+}
+
+/** Service that provides configuration for the Wultra Digital Onboarding SDK. */
+declare class WDOConfigurationService extends WDOBaseConfigurationService {
+    /** PowerAuth instance */
+    readonly powerauth: PowerAuth;
+    /**
+     * 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);
+}
+
+/** 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;
+}
+
+/** 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 activated when trying to use it */
+    powerauthNotActivated = "POWERAUTH_NOT_ACTIVATED",
+    /** OTP verification failed */
+    otpFailed = "OTP_FAILED"
+}
+export { Side, UploadState, WDOActivationService, WDOConfigurationService, WDOConsentResponse, WDOCreateDocumentSubmitFileSide, WDODocumentFile, WDODocumentSide, WDODocumentStatus, WDODocumentSubmitFileSide, WDODocumentSubmitFileType, WDODocumentType, WDODocumentTypeSides, WDODocumentTypeToSubmitType, WDOEndStateReason, WDOError, WDOErrorReason, WDOIdentityVerificationPhase, WDOIdentityVerificationStatus, WDOLogLevel, WDOLogger, WDOOnboardingStatus, WDOScannedDocument, WDOStatusCheckReason, WDOVerificationScanProcess, WDOVerificationService, WDOVerificationStateType };
+export type { Base64EncodedJPEG, WDOConfigurationDocument, WDOConfigurationResponse, WDODocument, WDODocumentStatusResponse, WDODocumentSubmitFile, WDODocumentsToScanSelectState, WDOEndStateState, WDOFailedState, WDOIdentityConfig, WDOIdentityStatusResponse, WDOIntroState, WDOLoggerListener, WDOOtpState, WDOPresenceCheckState, WDOProcessRequest, WDOProcessResponse, WDOProcessingState, WDOScanDocumentState, WDOSuccessState, WDOVerificationServiceListener, WDOVerificationState, WDOVerifyOTPResponse };