uqudosdk-capacitor 2.2.1

package/dist/esm/index.d.ts

@@ -0,0 +1,318 @@
+import type { UqudoIdPlugin } from './definitions';
+declare const UqudoId: UqudoIdPlugin;
+export * from './definitions';
+export { UqudoId };
+export declare class EnrollmentBuilder {
+    private documentList;
+    private authorizationToken?;
+    private nonce?;
+    private isRootedDeviceAllowed?;
+    private isSecuredWindowsDisabled?;
+    private facialRecognitionSpecification?;
+    private lookupConfiguration?;
+    private backgroundCheckConfiguration?;
+    private sessionId?;
+    private userIdentifier?;
+    private isReturnDataForIncompleteSession?;
+    private appearanceMode;
+    setToken(token: string): EnrollmentBuilder;
+    setNonce(nonce: string): EnrollmentBuilder;
+    setSessionId(sessionId: string): EnrollmentBuilder;
+    setUserIdentifier(userIdentifier: string): EnrollmentBuilder;
+    enableRootedDeviceUsage(): EnrollmentBuilder;
+    disableSecureWindow(): EnrollmentBuilder;
+    enableFacialRecognition(facialRecognitionConfigurationBuilder?: FacialRecognitionConfiguration): EnrollmentBuilder;
+    enableBackgroundCheck(backgroundCheckConfiguration: BackgroundCheckConfiguration): EnrollmentBuilder;
+    returnDataForIncompleteSession(): EnrollmentBuilder;
+    enableLookup(documents?: DocumentType[]): EnrollmentBuilder;
+    add(document: Document): EnrollmentBuilder;
+    setAppearanceMode(appearanceMode: AppearanceMode): EnrollmentBuilder;
+    build(): Enrollment;
+}
+export declare class Enrollment {
+    private documentList?;
+    private authorizationToken?;
+    private nonce?;
+    private isRootedDeviceAllowed?;
+    private isSecuredWindowsDisabled?;
+    private facialRecognitionSpecification?;
+    private backgroundCheckConfiguration?;
+    private lookupConfiguration?;
+    private sessionId?;
+    private userIdentifier?;
+    private isReturnDataForIncompleteSession?;
+    private appearanceMode?;
+    constructor(documentList?: Document[], authorizationToken?: string, nonce?: string, isRootedDeviceAllowed?: boolean, isSecuredWindowsDisabled?: boolean, facialRecognitionSpecification?: FacialRecognitionConfiguration, backgroundCheckConfiguration?: BackgroundCheckConfiguration, lookupConfiguration?: LookupConfiguration, sessionId?: string, userIdentifier?: string, isReturnDataForIncompleteSession?: boolean, appearanceMode?: AppearanceMode);
+}
+export declare class FacialRecognitionConfigurationBuilder {
+    private isHelpPageDisabled?;
+    private isEnrollFace?;
+    private scanMinimumMatchLevel?;
+    private readMinimumMatchLevel?;
+    private maxAttempts?;
+    disableHelpPage(): FacialRecognitionConfigurationBuilder;
+    enrollFace(): FacialRecognitionConfigurationBuilder;
+    setScanMinimumMatchLevel(scanMinimumMatchLevel: number): FacialRecognitionConfigurationBuilder;
+    setReadMinimumMatchLevel(readMinimumMatchLevel: number): FacialRecognitionConfigurationBuilder;
+    setMaxAttempts(maxAttempts: number): FacialRecognitionConfigurationBuilder;
+    build(): FacialRecognitionConfiguration;
+}
+export declare class FacialRecognitionConfiguration {
+    private isHelpPageDisabled?;
+    private enrollFace?;
+    private scanMinimumMatchLevel?;
+    private readMinimumMatchLevel?;
+    private maxAttempts?;
+    constructor(isHelpPageDisabled?: boolean, enrollFace?: boolean, scanMinimumMatchLevel?: number, readMinimumMatchLevel?: number, maxAttempts?: number);
+}
+export declare class BackgroundCheckConfigurationBuilder {
+    private isDisableConsent?;
+    private backgroundCheckType;
+    private monitoringEnabled?;
+    private isSkipView?;
+    disableConsent(): BackgroundCheckConfigurationBuilder;
+    enableMonitoring(): BackgroundCheckConfigurationBuilder;
+    setBackgroundCheckType(backgroundCheckType: BackgroundCheckType): BackgroundCheckConfigurationBuilder;
+    skipView(): BackgroundCheckConfigurationBuilder;
+    build(): BackgroundCheckConfiguration;
+}
+export declare class LookupConfiguration {
+    private documentsList?;
+    constructor(documents?: DocumentType[]);
+}
+export declare class BackgroundCheckConfiguration {
+    private disableConsent?;
+    private backgroundCheckType;
+    private monitoringEnabled?;
+    private skipView?;
+    constructor(backgroundCheckType: BackgroundCheckType, disableConsent?: boolean, monitoringEnabled?: boolean, skipView?: boolean);
+}
+export declare class Document {
+    private documentType?;
+    private readingConfiguration?;
+    private isHelpPageDisabled?;
+    private faceScanMinimumMatchLevel?;
+    private faceReadMinimumMatchLevel?;
+    private isExpiredDocumentValidateDisabled?;
+    private isFrontSideReviewEnabled?;
+    private isBackSideReviewEnabled?;
+    private isUploadEnabled?;
+    private isPhotoQualityDetectionEnabled?;
+    private minimumAge?;
+    constructor(type?: string, readConfig?: ReadingConfiguration, isHelpPageDisabled?: boolean, faceScanLevel?: number, faceReadLevel?: number, isExpiredDocumentValidateDisabled?: boolean, isFrontSideReviewEnabled?: boolean, isBackSideReviewEnabled?: boolean, isUploadEnabled?: boolean, isPhotoQualityDetectionEnabled?: boolean, minimumAge?: number);
+}
+export declare class DocumentBuilder {
+    private documentType?;
+    private isHelpPageDisabled?;
+    private readingConfiguration?;
+    private faceScanMinimumMatchLevel?;
+    private faceReadMinimumMatchLevel?;
+    private minimumAge?;
+    private isExpiredDocumentValidateDisabled?;
+    private isFrontSideReviewEnabled?;
+    private isBackSideReviewEnabled?;
+    private isUploadEnabled?;
+    private isPhotoQualityDetectionEnabled?;
+    setDocumentType(documentType: string): DocumentBuilder;
+    disableHelpPage(): DocumentBuilder;
+    enableReading(readingConfiguration?: ReadingConfiguration): DocumentBuilder;
+    disableExpiryValidation(): DocumentBuilder;
+    setFaceScanMinimumMatchLevel(faceScanMinimumMatchLevel: number): DocumentBuilder;
+    setFaceReadMinimumMatchLevel(faceReadMinimumMatchLevel: number): DocumentBuilder;
+    enableScanReview(isFrontSideReviewEnabled: boolean, isBackSideReviewEnabled: boolean): DocumentBuilder;
+    enableUpload(): DocumentBuilder;
+    enableAgeVerification(minAge: number): DocumentBuilder;
+    /**
+     * @deprecated Ignored and enabled by default. Will be removed in a future release
+     */
+    enablePhotoQualityDetection(): DocumentBuilder;
+    build(): Document;
+}
+export declare class ReadingConfiguration {
+    private forceReading?;
+    private forceReadingIfSupported?;
+    private timeoutInSeconds?;
+    constructor(forceRead?: boolean, forceReadIfSupported?: boolean, timeoutInSeconds?: number);
+}
+export declare class ReadingConfigurationBuilder {
+    private forceReadingValue?;
+    private forceReadingIfSupportedValue?;
+    private timeoutInSeconds?;
+    forceReading(value: boolean): ReadingConfigurationBuilder;
+    forceReadingIfSupported(value: boolean): ReadingConfigurationBuilder;
+    forceReadingTimeout(value: number): ReadingConfigurationBuilder;
+    build(): ReadingConfiguration;
+}
+export declare class AccountRecoveryConfigurationBuilder {
+    private authorizationToken?;
+    private enrollmentIdentifier?;
+    private nonce?;
+    private isRootedDeviceAllowed?;
+    private isSecuredWindowsDisabled?;
+    private minimumMatchLevel?;
+    private maxAttempts?;
+    private isReturnDataForIncompleteSession?;
+    private appearanceMode?;
+    /**
+     * Pass the token received from Uqudo to authenticate the SDK
+     */
+    setToken(token: string): AccountRecoveryConfigurationBuilder;
+    /**
+     * Pass the enrollment identifier for the account to be recovered
+     */
+    setEnrollmentIdentifier(identifier: string): AccountRecoveryConfigurationBuilder;
+    /**
+     * You can pass your custom nonce to provide security to the enrollment process
+     */
+    setNonce(nonce: string): AccountRecoveryConfigurationBuilder;
+    /**
+     * Whether you want the sdk to run on the rooted devices or not. By default it is false
+     */
+    enableRootedDeviceUsage(): AccountRecoveryConfigurationBuilder;
+    /**
+     * To allow user to capture/record screenshot or video of the screen on the device app is installed.
+     * Default is screenshot and video recording of the screen is not allowed
+     */
+    disableSecureWindow(): AccountRecoveryConfigurationBuilder;
+    /**
+     * Set this to use the value passed for facialRecognition for Account Recovery
+     */
+    setMinimumMatchLevel(value: number): AccountRecoveryConfigurationBuilder;
+    setMaxAttempts(value: number): AccountRecoveryConfigurationBuilder;
+    returnDataForIncompleteSession(): AccountRecoveryConfigurationBuilder;
+    setAppearanceMode(appearanceMode: AppearanceMode): AccountRecoveryConfigurationBuilder;
+    /**
+     * @returns Intent with the configuration and the token needed to authorize the activity to
+     * recover the account
+     */
+    build(): AccountRecoveryConfiguration;
+}
+export declare class AccountRecoveryConfiguration {
+    private token?;
+    private enrollmentIdentifier?;
+    private nonce?;
+    private isRootedDeviceAllowed?;
+    private isSecuredWindowsDisabled?;
+    private minimumMatchLevel?;
+    private maxAttempts?;
+    private isReturnDataForIncompleteSession?;
+    private appearanceMode?;
+    constructor(token?: string, enrollmentIdentifier?: string, nonce?: string, isRootedDeviceAllowed?: boolean, isSecuredWindowsDisabled?: boolean, minimumMatchLevel?: number, maxAttempts?: number, isReturnDataForIncompleteSession?: boolean, appearanceMode?: AppearanceMode);
+}
+export declare class FaceSessionConfigurationBuilder {
+    private authorizationToken?;
+    private sessionId?;
+    private nonce?;
+    private isRootedDeviceAllowed?;
+    private isSecuredWindowsDisabled?;
+    private minimumMatchLevel?;
+    private maxAttempts?;
+    private isReturnDataForIncompleteSession?;
+    private appearanceMode?;
+    /**
+     * Pass the token received from Uqudo to authenticate the SDK
+     */
+    setToken(token: string): FaceSessionConfigurationBuilder;
+    /**
+     * Pass the enrollment identifier for facial recognition
+     */
+    setSessionId(identifier: string): FaceSessionConfigurationBuilder;
+    /**
+     * You can pass your custom nonce to provide security to the facial recognition process
+     */
+    setNonce(nonce: string): FaceSessionConfigurationBuilder;
+    /**
+     * Whether you want the sdk to run on the rooted devices or not. By default it is false
+     */
+    enableRootedDeviceUsage(): FaceSessionConfigurationBuilder;
+    /**
+     * To allow user to capture/record screenshot or video of the screen on the device app is installed.
+     * Default is screenshot and video recording of the screen is not allowed
+     */
+    disableSecureWindow(): FaceSessionConfigurationBuilder;
+    /**
+     * Set this to use the value passed for facialRecognition for facial recognition
+     */
+    setMinimumMatchLevel(value: number): FaceSessionConfigurationBuilder;
+    setMaxAttempts(value: number): FaceSessionConfigurationBuilder;
+    returnDataForIncompleteSession(): FaceSessionConfigurationBuilder;
+    setAppearanceMode(appearanceMode: AppearanceMode): FaceSessionConfigurationBuilder;
+    /**
+     * @returns Intent with the configuration and the token needed to authorize the activity to
+     * facial recognition
+     */
+    build(): FaceSessionConfiguration;
+}
+export declare class FaceSessionConfiguration {
+    private token?;
+    private sessionId?;
+    private nonce?;
+    private isRootedDeviceAllowed?;
+    private isSecuredWindowsDisabled?;
+    private minimumMatchLevel?;
+    private maxAttempts?;
+    private isReturnDataForIncompleteSession?;
+    private appearanceMode?;
+    constructor(token?: string, sessionId?: string, nonce?: string, isRootedDeviceAllowed?: boolean, isSecuredWindowsDisabled?: boolean, minimumMatchLevel?: number, maxAttempts?: number, isReturnDataForIncompleteSession?: boolean, appearanceMode?: AppearanceMode);
+}
+export declare enum DocumentType {
+    BHR_ID = "BHR_ID",
+    GENERIC_ID = "GENERIC_ID",
+    KWT_ID = "KWT_ID",
+    OMN_ID = "OMN_ID",
+    PAK_ID = "PAK_ID",
+    PASSPORT = "PASSPORT",
+    SAU_ID = "SAU_ID",
+    UAE_ID = "UAE_ID",
+    UAE_DL = "UAE_DL",
+    UAE_VISA = "UAE_VISA",
+    UAE_VL = "UAE_VL",
+    QAT_ID = "QAT_ID",
+    NLD_DL = "NLD_DL",
+    DEU_ID = "DEU_ID",
+    SDN_ID = "SDN_ID",
+    SDN_DL = "SDN_DL",
+    SDN_VL = "SDN_VL",
+    GHA_ID = "GHA_ID",
+    NGA_DL = "NGA_DL",
+    NGA_VOTER_ID = "NGA_VOTER_ID",
+    NGA_NIN = "NGA_NIN",
+    GBR_DL = "GBR_DL",
+    SAU_DL = "SAU_DL",
+    ZAF_ID = "ZAF_ID",
+    ZAF_DL = "ZAF_DL",
+    EGY_ID = "EGY_ID",
+    RWA_ID = "RWA_ID",
+    KEN_ID = "KEN_ID",
+    GHA_DL = "GHA_DL",
+    GHA_VOTER_ID = "GHA_VOTER_ID",
+    GHA_SSNIT = "GHA_SSNIT",
+    UGA_ID = "UGA_ID",
+    IND_ID = "IND_ID",
+    OMN_ID_NATIONAL = "OMN_ID_NATIONAL",
+    OMN_ID_RESIDENT = "OMN_ID_RESIDENT",
+    SEN_ID = "SEN_ID",
+    UGA_VOTER_ID = "UGA_VOTER_ID"
+}
+export declare enum BackgroundCheckType {
+    RDC = "RDC",
+    DOW_JONES = "DOW_JONES"
+}
+export declare enum AppearanceMode {
+    SYSTEM = "SYSTEM",
+    LIGHT = "LIGHT",
+    DARK = "DARK"
+}
+export declare class UqudoPlugin {
+    init(): void;
+    setLocale(locale: string): void;
+    enroll(enrollObj: Enrollment): Promise<{
+        value: string;
+    }>;
+    recover(recoverObj: AccountRecoveryConfiguration): Promise<{
+        value: string;
+    }>;
+    faceSession(faceSessionObj: FaceSessionConfiguration): Promise<{
+        value: string;
+    }>;
+}