Verifying user

const powerAuth: PowerAuth // configured and activated PowerAuth instance

try {
    const status = await powerAuth.fetchActivationStatus()
    if (WDOVerificationService.isVerificationRequired(status)) {
        // navigate to the verification flow 
        // and call `WDOVerificationService.status`
    } else {
        // handle PA status
    }
} catch (error) {
    // handle error
}

/** 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"
}

const powerAuth = new PowerAuth("my-pa-instance")
powerAuth.configure({
    configuration: "ARCB+...jg==", // base64 PowerAuth configuration
    baseEndpointUrl: "https://my-server-deployment.com/enrollment-server/"
})
const verification = new WDOVerificationService(
    powerAuth,
    "https://my-server-deployment.com/enrollment-server-onboarding/"
)

const verification: WDOVerificationService // configured instance
try {
    const vfStatus = await verification.status()
    // handle `WDOVerificationState` state and navigate to the expected screen
} catch (error) {
    if (error.verificationState) {
        // show expected screen based on the state
    } else {
        // navigate to error screen
    }
}

const verification: WDOVerificationService // configured instance
try {
    const consentTextResponse = await verification.consentGet()
    // state will be in the `consent` case here - display the consent screen
} catch (error) {
    if (error.verificationState) {
        // show expected screen based on the state
    } else {
        // navigate to error screen
    }
}

const verification: WDOVerificationService // configured instance
try {
    const approvalResult = await verification.consentApprove()
    // state will be in the `documentsToScanSelect` case here - display the document selector
} catch (error) {
    if (error.verificationState) {
        // show expected screen based on the state
    } else {
        // navigate to error screen
    }
}

const verification: WDOVerificationService // configured instance
try {
    const docTypesResult = await verification.documentsSetSelectedTypes([
        WDODocumentType.idCard,
        WDODocumentType.driversLicense
    ])
    // state will be in the `scanDocument` case here - display the document scanner
} catch (error) {
    if (error.verificationState) {
        // show expected screen based on the state
    } else {
        // navigate to error screen
    }
}

const verification: WDOVerificationService // configured instance

const passportToUpload = WDODocumentFile(
    "BASE64_ENCODED_IMAGE_DATA", // raw image data from the document scanning library/photo camera
    WDODocumentType.passport,
    WDODocumentSide.front, // passport has only front side
    undefined, // use only when re-uploading the file (for example when first upload was rejected because of a blur)
    undefined // optional, use when provided by the document scanning library
)
try {
    const result = await verification.documentsSubmit([passportToUpload])
    // state will be in the `processing` case here - display the processing screen
} catch (error) {
    if (error.verificationState) {
        // show expected screen based on the state
    } else {
        // navigate to error screen
    }
}

/** 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);
}

const verification: WDOVerificationService // configured instance
try {
    const otpStatus = await verificationService.verifyOTP("123456")
    // React to a new state returned in the result
} catch (error) {
    // handle error
}