cordova-digital-onboarding 1.0.0 → 1.0.1

package/lib/index.d.ts

@@ -0,0 +1,691 @@
+/** 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. */
+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"
+}
+
+/** 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>;
+    };
+}
+
+/** 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.
+     */
+    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>;
+}
+
+/**
+ * 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);
+}
+
+/**
+ * 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 = Intro | Consent | DocumentsToScanSelect | ScanDocument | Processing | PresenceCheck | Otp | Failed | EndState | Success;
+/**
+ * Show the verification introduction screen where the user can start the activation.
+ *
+ * The next step should be calling the `consentGet()`.
+ */
+interface Intro {
+    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;
+}
+/**
+ * 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 DocumentsToScanSelect {
+    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 ScanDocument {
+    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 Processing {
+    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 PresenceCheck {
+    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 Otp {
+    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 Failed {
+    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 EndState {
+    type: WDOVerificationStateType.endState;
+    /** Reason for the end state */
+    reason: WDOEndStateReason;
+}
+/**
+ * Verification was successfully ended. Continue into your app flow.
+ */
+interface Success {
+    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 `consentGet()`.
+     */
+    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.
+     *
+     * 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;
+}
+/**
+ * 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<WDOVerificationState>;
+    /**
+     * Approves the consent for this process and starts the activation.
+     */
+    consentApprove(): 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<any>;
+    /**
+     * 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<any>;
+    /**
+     * 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;
+}
+export { Side, UploadState, WDOActivationService, WDOConfigurationService, WDODocumentFile, WDODocumentSide, WDODocumentType, WDODocumentTypeSides, WDOEndStateReason, WDOLogLevel, WDOLogger, WDOScannedDocument, WDOStatusCheckReason, WDOVerificationScanProcess, WDOVerificationService, WDOVerificationStateType };
+export type { Base64EncodedJPEG, WDOLoggerListener, WDOVerificationState };