type Nullable<T> = T | null | undefined
declare function KtSingleton<T>(): T & (abstract new() => any);
/** @deprecated  */
export declare const initHook: { get(): any; };
export declare class CameraProps {
    constructor(backgroundColor?: string);
    get backgroundColor(): string;
    shouldShowAnimation(): boolean;
    copy(backgroundColor?: string): CameraProps;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace CameraProps.$metadata$ {
    const constructor: abstract new () => CameraProps;
}
export declare class Coordinates {
    constructor(topLeft: ScreenPoint, bottomRight: ScreenPoint, center: ScreenPoint);
    get topLeft(): ScreenPoint;
    get bottomRight(): ScreenPoint;
    get center(): ScreenPoint;
    copy(topLeft?: ScreenPoint, bottomRight?: ScreenPoint, center?: ScreenPoint): Coordinates;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Coordinates.$metadata$ {
    const constructor: abstract new () => Coordinates;
}
export declare class ScreenPoint {
    constructor(x: number, y: number);
    get x(): number;
    get y(): number;
    copy(x?: number, y?: number): ScreenPoint;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ScreenPoint.$metadata$ {
    const constructor: abstract new () => ScreenPoint;
}
export declare interface ITruliooImageFeedback {
    readonly imageId: string;
    readonly detectionType: DetectionType;
    readonly imageFeedbacks: Array<string>;
    readonly __doNotUseOrImplementIt: {
        readonly "com.trulioo.docv.sdk.capture.contract.ITruliooImageFeedback": unique symbol;
    };
}
export declare interface ITruliooVerifyFeedback {
    readonly isVerifyAttemptAvailable: boolean;
    readonly verifyResponses: Array<string>;
    readonly __doNotUseOrImplementIt: {
        readonly "com.trulioo.docv.sdk.capture.contract.ITruliooVerifyFeedback": unique symbol;
    };
}
export declare class TruliooCameraConfig {
    constructor(detectionType?: DetectionType);
    get detectionType(): DetectionType;
    copy(detectionType?: DetectionType): TruliooCameraConfig;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TruliooCameraConfig.$metadata$ {
    const constructor: abstract new () => TruliooCameraConfig;
}
export declare abstract class DetectionType {
    private constructor();
    static get DOCUMENT(): DetectionType & {
        get name(): "DOCUMENT";
        get ordinal(): 0;
    };
    static get BIOMETRIC_SELFIE(): DetectionType & {
        get name(): "BIOMETRIC_SELFIE";
        get ordinal(): 1;
    };
    get name(): "DOCUMENT" | "BIOMETRIC_SELFIE";
    get ordinal(): 0 | 1;
    static values(): Array<DetectionType>;
    static valueOf(value: string): DetectionType;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DetectionType.$metadata$ {
    const constructor: abstract new () => DetectionType;
}
export declare class Resolution {
    constructor(width: number, height: number);
    get width(): number;
    get height(): number;
    isAvailable(): boolean;
    copy(width?: number, height?: number): Resolution;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Resolution.$metadata$ {
    const constructor: abstract new () => Resolution;
}
export declare namespace Resolution {
    abstract class Companion {
        static readonly getInstance: () => typeof Companion.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor {
            get UNAVAILABLE(): Resolution;
            private constructor();
        }
    }
}
export declare class TruliooCameraProps {
    constructor(backgroundColor?: string);
    get backgroundColor(): string;
    shouldShowAnimation(): boolean;
    copy(backgroundColor?: string): TruliooCameraProps;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TruliooCameraProps.$metadata$ {
    const constructor: abstract new () => TruliooCameraProps;
}
export declare class TruliooError extends /* Error */ Error {
    private constructor();
    get code(): number;
    get errorMessage(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TruliooError.$metadata$ {
    const constructor: abstract new () => TruliooError;
}
export declare namespace TruliooError {
    abstract class GeneralError {
        static readonly getInstance: () => typeof GeneralError.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace GeneralError.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooError.$metadata$.constructor {
            toString(): string;
            hashCode(): number;
            equals(other: Nullable<any>): boolean;
            private constructor();
        }
    }
    abstract class FeedbackManuallyStopped {
        static readonly getInstance: () => typeof FeedbackManuallyStopped.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace FeedbackManuallyStopped.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooError.$metadata$.constructor {
            toString(): string;
            hashCode(): number;
            equals(other: Nullable<any>): boolean;
            private constructor();
        }
    }
    abstract class CameraIsNotReady {
        static readonly getInstance: () => typeof CameraIsNotReady.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace CameraIsNotReady.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooError.$metadata$.constructor {
            toString(): string;
            hashCode(): number;
            equals(other: Nullable<any>): boolean;
            private constructor();
        }
    }
    abstract class SdkIsNotInitialized {
        static readonly getInstance: () => typeof SdkIsNotInitialized.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace SdkIsNotInitialized.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooError.$metadata$.constructor {
            toString(): string;
            hashCode(): number;
            equals(other: Nullable<any>): boolean;
            private constructor();
        }
    }
    abstract class ParentElementNotFound {
        static readonly getInstance: () => typeof ParentElementNotFound.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace ParentElementNotFound.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooError.$metadata$.constructor {
            toString(): string;
            hashCode(): number;
            equals(other: Nullable<any>): boolean;
            private constructor();
        }
    }
    abstract class CameraPermissionDenied {
        static readonly getInstance: () => typeof CameraPermissionDenied.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace CameraPermissionDenied.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooError.$metadata$.constructor {
            toString(): string;
            hashCode(): number;
            equals(other: Nullable<any>): boolean;
            private constructor();
        }
    }
    abstract class CameraFrameProcessFailed {
        static readonly getInstance: () => typeof CameraFrameProcessFailed.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace CameraFrameProcessFailed.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooError.$metadata$.constructor {
            toString(): string;
            hashCode(): number;
            equals(other: Nullable<any>): boolean;
            private constructor();
        }
    }
    abstract class ResolutionNotAvailable {
        static readonly getInstance: () => typeof ResolutionNotAvailable.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace ResolutionNotAvailable.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooError.$metadata$.constructor {
            toString(): string;
            hashCode(): number;
            equals(other: Nullable<any>): boolean;
            private constructor();
        }
    }
    class UnexpectedError extends TruliooError.$metadata$.constructor {
        constructor(message?: Nullable<string>);
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace UnexpectedError.$metadata$ {
        const constructor: abstract new () => UnexpectedError;
    }
}
export declare interface ITruliooCamera {
    readonly id: string;
    readonly detectionType: DetectionType;
    render(parentElementId: string, cameraProps?: Nullable<TruliooCameraProps>): Promise<any>;
    onCaptureRegion(onRegionChange: (p0: Coordinates) => void): void;
    startFeedback(): Promise<ITruliooCaptureResponse>;
    startFeedbackWithFilter(filter: (p0: ITruliooImageFeedback) => boolean): Promise<ITruliooCaptureResponse>;
    stopFeedback(): void;
    onFeedbackState(feedback: (p0: string) => void): void;
    captureLatestFrame(): Promise<ITruliooManualCaptureResponse>;
    remove(): void;
    resume(): void;
    getResolution(): Promise<Resolution>;
    readonly __doNotUseOrImplementIt: {
        readonly "com.trulioo.docv.sdk.capture.ITruliooCamera": unique symbol;
    };
}
export declare interface ITruliooCaptureResponse extends ICaptureResponse, ITruliooImageFeedback {
    readonly __doNotUseOrImplementIt: {
        readonly "com.trulioo.docv.sdk.capture.ITruliooCaptureResponse": unique symbol;
    } & ICaptureResponse["__doNotUseOrImplementIt"] & ITruliooImageFeedback["__doNotUseOrImplementIt"];
}
export declare interface ITruliooManualCaptureResponse extends ICaptureResponse {
    readonly __doNotUseOrImplementIt: {
        readonly "com.trulioo.docv.sdk.capture.ITruliooManualCaptureResponse": unique symbol;
    } & ICaptureResponse["__doNotUseOrImplementIt"];
}
export declare interface ICaptureResponse {
    readonly imageId: string;
    acceptImage(): Promise<any>;
    verifyImage(): Promise<ITruliooVerifyFeedback>;
    readonly __doNotUseOrImplementIt: {
        readonly "com.trulioo.docv.sdk.capture.ICaptureResponse": unique symbol;
    };
}
export declare interface ITruliooCapture {
    initialize(shortCode: string): Promise<string>;
    createTruliooCamera(config?: Nullable<TruliooCameraConfig>): ITruliooCamera;
    submit(): Promise<any>;
    reset(): void;
    readonly __doNotUseOrImplementIt: {
        readonly "com.trulioo.docv.sdk.capture.ITruliooCapture": unique symbol;
    };
}
export declare class TruliooCamera implements ITruliooCamera {
    constructor(detectionType: DetectionType, id?: string, viewModel?: any/* ICameraViewModel */, cameraView?: any/* IWebCameraView */, cameraDispatcher?: any/* CoroutineDispatcher */);
    get detectionType(): DetectionType;
    get id(): string;
    render(parentElementId: string, cameraProps?: Nullable<TruliooCameraProps>): Promise<any>;
    onCaptureRegion(onRegionChange: (p0: Coordinates) => void): void;
    startFeedback(): Promise<ITruliooCaptureResponse>;
    startFeedbackWithFilter(filter: (p0: ITruliooImageFeedback) => boolean): Promise<ITruliooCaptureResponse>;
    stopFeedback(): void;
    onFeedbackState(feedback: (p0: string) => void): void;
    captureLatestFrame(): Promise<ITruliooManualCaptureResponse>;
    resume(): void;
    remove(): void;
    getResolution(): Promise<Resolution>;
    readonly __doNotUseOrImplementIt: ITruliooCamera["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TruliooCamera.$metadata$ {
    const constructor: abstract new () => TruliooCamera;
}
export declare abstract class TruliooCapture {
    static readonly getInstance: () => typeof TruliooCapture.$metadata$.type;
    private constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TruliooCapture.$metadata$ {
    abstract class type extends KtSingleton<constructor>() {
        private constructor();
    }
    abstract class constructor implements ITruliooCapture {
        initialize(shortCode: string): Promise<string>;
        createTruliooCamera(config?: Nullable<TruliooCameraConfig>): ITruliooCamera;
        submit(): Promise<any>;
        reset(): void;
        readonly __doNotUseOrImplementIt: ITruliooCapture["__doNotUseOrImplementIt"];
        private constructor();
    }
}
export declare class TruliooCaptureResponse implements ITruliooCaptureResponse {
    constructor(detectionType: DetectionType, imageDecision: any/* IImageDecision */, cameraFlow: any/* ISDKCameraBridge */);
    get detectionType(): DetectionType;
    get imageId(): string;
    get imageFeedbacks(): Array<string>;
    acceptImage(): Promise<any>;
    verifyImage(): Promise<ITruliooVerifyFeedback>;
    readonly __doNotUseOrImplementIt: ITruliooCaptureResponse["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TruliooCaptureResponse.$metadata$ {
    const constructor: abstract new () => TruliooCaptureResponse;
}
export declare class TruliooManualCaptureResponse implements ITruliooManualCaptureResponse {
    constructor(imageId: string, cameraFlow: any/* ISDKCameraBridge */);
    get imageId(): string;
    acceptImage(): Promise<any>;
    verifyImage(): Promise<ITruliooVerifyFeedback>;
    readonly __doNotUseOrImplementIt: ITruliooManualCaptureResponse["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TruliooManualCaptureResponse.$metadata$ {
    const constructor: abstract new () => TruliooManualCaptureResponse;
}
export declare class Trulioo implements ITrulioo {
    constructor();
    initialize(shortcode: string): Promise<TruliooResult.Authorized>;
    launch(parentId: string, eventBuilder: EventBuilder): Promise<TruliooResult>;
    readonly __doNotUseOrImplementIt: ITrulioo["__doNotUseOrImplementIt"];
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Trulioo.$metadata$ {
    const constructor: abstract new () => Trulioo;
}
export declare interface ITrulioo {
    initialize(shortcode: string): Promise<TruliooResult.Authorized>;
    launch(parentId: string, eventBuilder: EventBuilder): Promise<TruliooResult>;
    readonly __doNotUseOrImplementIt: {
        readonly "com.trulioo.docv.ui.contract.ITrulioo": unique symbol;
    };
}
export declare abstract class TruliooResult {
    protected constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace TruliooResult.$metadata$ {
    const constructor: abstract new () => TruliooResult;
}
export declare namespace TruliooResult {
    class Authorized extends TruliooResult.$metadata$.constructor {
        constructor(transactionId: string);
        get transactionId(): string;
        copy(transactionId?: string): TruliooResult.Authorized;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Authorized.$metadata$ {
        const constructor: abstract new () => Authorized;
    }
    abstract class Complete {
        static readonly getInstance: () => typeof Complete.$metadata$.type;
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Complete.$metadata$ {
        abstract class type extends KtSingleton<constructor>() {
            private constructor();
        }
        abstract class constructor extends TruliooResult.$metadata$.constructor {
            private constructor();
        }
    }
    class Error extends TruliooResult.$metadata$.constructor {
        constructor(message: string, code?: Nullable<number>, transactionId?: Nullable<string>);
        get message(): string;
        get code(): Nullable<number>;
        get transactionId(): Nullable<string>;
        toString(): string;
        copy(message?: string, code?: Nullable<number>, transactionId?: Nullable<string>): TruliooResult.Error;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Error.$metadata$ {
        const constructor: abstract new () => Error;
    }
}
export declare abstract class Response {
    protected constructor();
    abstract asJs(): any;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Response.$metadata$ {
    const constructor: abstract new () => Response;
}
export declare namespace Response {
    class Success extends Response.$metadata$.constructor {
        constructor(transactionId: Nullable<string>);
        get transactionId(): Nullable<string>;
        asJs(): any;
        copy(transactionId?: Nullable<string>): Response.Success;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Success.$metadata$ {
        const constructor: abstract new () => Success;
    }
    class Error extends Response.$metadata$.constructor {
        constructor(code: number, message: Nullable<string>);
        get code(): number;
        get message(): Nullable<string>;
        asJs(): any;
        copy(code?: number, message?: Nullable<string>): Response.Error;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Error.$metadata$ {
        const constructor: abstract new () => Error;
    }
    class Exception extends Response.$metadata$.constructor {
        constructor(message: Nullable<string>);
        get message(): Nullable<string>;
        asJs(): any;
        copy(message?: Nullable<string>): Response.Exception;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Exception.$metadata$ {
        const constructor: abstract new () => Exception;
    }
}
export declare class EventBuilder {
    constructor();
    setCallbacks(obj: Nullable<ListenerCallback>): EventBuilder;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EventBuilder.$metadata$ {
    const constructor: abstract new () => EventBuilder;
}
export declare class ListenerCallback {
    constructor(obj?: any);
    get onComplete(): (p0: Response.Success) => void;
    get onError(): (p0: Response.Error) => void;
    get onException(): (p0: Response.Exception) => void;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace ListenerCallback.$metadata$ {
    const constructor: abstract new () => ListenerCallback;
}