@unissey-web/web-components 3.8.0-beta.5

package/dist/index.d.ts

@@ -0,0 +1,1132 @@
+import * as lit_html from 'lit-html';
+import * as lit from 'lit';
+import { LitElement, PropertyValues as PropertyValues$1 } from 'lit';
+import { PropertyValues } from '@lit/reactive-element';
+import { UnisseySession, SessionConfig as SessionConfig$1, AcquisitionPreset as AcquisitionPreset$1, LogLevel as LogLevel$1, StatusEvent } from '@unissey/sdk-web-js';
+
+type ButtonVariant = "contained" | "outlined";
+declare class Button extends LitElement {
+    variant: ButtonVariant;
+    disabled: boolean;
+    width: string;
+    static properties: {
+        variant: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        width: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        disabled: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+    };
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+
+type HintMessages = {
+    left: string;
+    right: string;
+    up: string;
+    down: string;
+    perfect: string;
+    closer: string;
+    record: string;
+    nil: string;
+};
+type HintType = keyof HintMessages;
+type FaceChecker = "enabled" | "disabled" | "disabled-on-retry";
+
+declare class OverlayHints extends LitElement {
+    hint: HintType;
+    message: string;
+    strings: HintMessages;
+    static properties: {
+        hint: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        message: {
+            state: boolean;
+        };
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+    };
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class CameraVideoOutlinedIcon extends LitElement {
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare const EN: {
+    videoRecorder: {
+        capture: string;
+        retry: string;
+        errors: {
+            noFace: string;
+        };
+        hints: {
+            up: string;
+            down: string;
+            perfect: string;
+            right: string;
+            left: string;
+            closer: string;
+            record: string;
+            nil: string;
+        };
+        forbiddenActionMessages: {
+            visibility: string;
+            focus: string;
+            keyboard: string;
+            default: string;
+        };
+        cameraErrorMessages: {
+            permissionDenied: string;
+            openFailed: string;
+            default: string;
+        };
+        rotationWhileCapturingErrorMessage: string;
+        activeChallengeMessages: {
+            rotateLeft: string;
+            rotateRight: string;
+            rotateUp: string;
+            rotateDown: string;
+        };
+    };
+    pictureRecorder: {
+        capture: string;
+    };
+    imageCaptureDirections: {
+        document: string;
+        face: string;
+        light: string;
+    };
+    videoRecordDirections: {
+        position: string;
+        face: string;
+        light: string;
+        camera: string;
+    };
+    pictureEditor: {
+        validate: string;
+    };
+    fileUpload: {
+        badType: string;
+        maxSize: string;
+        text: string;
+    };
+    retryResult: {
+        default: string;
+        retryMessage: string;
+        retriesLeft: {
+            _1: string;
+            _2: string;
+            _3: string;
+        };
+        retryBtn: string;
+        finishBtn: string;
+        covideMask: string;
+        brightness: string;
+    };
+    selfieCapture: {
+        back: string;
+        directionSubtitle: string;
+        recordBtnLabel: string;
+        title: string;
+        recordSubtitle: string;
+        acquisitionDuration: {
+            base: string;
+            singular: string;
+            plural: string;
+        };
+        directions: {
+            position: string;
+            face: string;
+            light: string;
+            camera: string;
+        };
+        recorder: {
+            capture: string;
+            retry: string;
+            errors: {
+                noFace: string;
+            };
+            hints: {
+                up: string;
+                down: string;
+                perfect: string;
+                right: string;
+                left: string;
+                closer: string;
+                record: string;
+                nil: string;
+            };
+            forbiddenActionMessages: {
+                visibility: string;
+                focus: string;
+                keyboard: string;
+                default: string;
+            };
+            cameraErrorMessages: {
+                permissionDenied: string;
+                openFailed: string;
+                default: string;
+            };
+            rotationWhileCapturingErrorMessage: string;
+            activeChallengeMessages: {
+                rotateLeft: string;
+                rotateRight: string;
+                rotateUp: string;
+                rotateDown: string;
+            };
+        };
+    };
+    referenceCapture: {
+        back: string;
+        title: string;
+        captureTitle: string;
+        editorTitle: string;
+        directionSubtitle: string;
+        pictureRecordSubtitle: string;
+        videoRecordSubtitle: string;
+        uploadBtn: string;
+        pictureBtn: string;
+        recordVidBtn: string;
+        retryPictureCaptureBtn: string;
+        retryVideoCaptureBtn: string;
+        replayValidation: string;
+        editor: {
+            validate: string;
+        };
+        directions: {
+            document: string;
+            face: string;
+            light: string;
+        };
+        videoRecorder: {
+            capture: string;
+            retry: string;
+            errors: {
+                noFace: string;
+            };
+            hints: {
+                up: string;
+                down: string;
+                perfect: string;
+                right: string;
+                left: string;
+                closer: string;
+                record: string;
+                nil: string;
+            };
+            forbiddenActionMessages: {
+                visibility: string;
+                focus: string;
+                keyboard: string;
+                default: string;
+            };
+            cameraErrorMessages: {
+                permissionDenied: string;
+                openFailed: string;
+                default: string;
+            };
+            rotationWhileCapturingErrorMessage: string;
+            activeChallengeMessages: {
+                rotateLeft: string;
+                rotateRight: string;
+                rotateUp: string;
+                rotateDown: string;
+            };
+        };
+        pictureRecorder: {
+            capture: string;
+        };
+        fileUpload: {
+            badType: string;
+            maxSize: string;
+            text: string;
+        };
+    };
+};
+type I18n = typeof EN;
+
+type InstructionMessage = {
+    message: string;
+    duration: number;
+};
+declare class Recorder extends LitElement {
+    session: UnisseySession | null;
+    sessionPromise: Promise<void> | null;
+    config: SessionConfig$1;
+    preset: AcquisitionPreset$1;
+    resultEvent: {
+        name: string;
+        mediaPropertyName: string;
+        includeMetadata: boolean;
+    };
+    mediaType: string;
+    faceChecker: FaceChecker;
+    instructionMessages: InstructionMessage[];
+    instructionMessage: string;
+    instructionTimer: number;
+    instructions: string[];
+    instructionNumber: number;
+    defaultStrings: {
+        capture: string;
+        retry: string;
+        errors: {
+            noFace: string;
+        };
+        hints: {
+            up: string;
+            down: string;
+            perfect: string;
+            right: string;
+            left: string;
+            closer: string;
+            record: string;
+            nil: string;
+        };
+        forbiddenActionMessages: {
+            visibility: string;
+            focus: string;
+            keyboard: string;
+            default: string;
+        };
+        cameraErrorMessages: {
+            permissionDenied: string;
+            openFailed: string;
+            default: string;
+        };
+        rotationWhileCapturingErrorMessage: string;
+        activeChallengeMessages: {
+            rotateLeft: string;
+            rotateRight: string;
+            rotateUp: string;
+            rotateDown: string;
+        };
+    };
+    strings: Partial<typeof EN.videoRecorder>;
+    captureButtonPicto: lit_html.TemplateResult<1>;
+    logLevel: LogLevel$1;
+    displayFlipCameraBtn: boolean | undefined;
+    hideCaptureBtn: boolean;
+    disconnected: boolean;
+    initSessionInprogress: boolean;
+    hints: HintType;
+    error: string;
+    sdkJsStatus: StatusEvent;
+    willRetryCapture: boolean;
+    retryCount: number;
+    isCameraFlipped: boolean;
+    faceDetectionFails: boolean;
+    static properties: {
+        preset: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        config: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        displayFlipCameraBtn: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+        hideCaptureBtn: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+        faceChecker: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        logLevel: {
+            attribute: string;
+            type: NumberConstructor;
+        };
+        instructionMessages: {
+            attribute: string;
+            type: ArrayConstructor;
+        };
+        hints: {
+            state: boolean;
+        };
+        error: {
+            state: boolean;
+        };
+        sdkJsStatus: {
+            state: boolean;
+        };
+        willRetryCapture: {
+            state: boolean;
+        };
+        instructions: {
+            state: boolean;
+        };
+        instructionMessage: {
+            state: boolean;
+        };
+        instructionTimer: {
+            state: boolean;
+        };
+    };
+    constructor();
+    retryCapture(): Promise<void>;
+    capture(): Promise<void>;
+    flipCamera(): Promise<void>;
+    protected firstUpdated(): void;
+    updated(_changedProperties: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private isRunning;
+    private getString;
+    private initSdkJs;
+    private releaseSdkJs;
+    private sdkJsListener_status;
+    private sdkJsListener_faceInfo;
+    private sdkJsListener_issue;
+    private sdkJsListener_activeChallenge;
+    private buildSessionConfig;
+    private callInitSession;
+    private initSession;
+    private handleBadFacePos;
+    private resetHints;
+    private setDimensionsToElement;
+    private adjustContainerSize;
+    private displaySpinner;
+    private hideSpinner;
+    displayError(message?: string): Promise<void>;
+    private hideError;
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class DirectionCard extends LitElement {
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+
+type VideoRecordDirectionsStrings = {
+    position: string;
+    face: string;
+    light: string;
+    camera: string;
+};
+declare class VideoRecordDirections extends LitElement {
+    strings: VideoRecordDirectionsStrings;
+    static properties: {
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+    };
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class PictureRecorder extends Recorder {
+    constructor();
+}
+
+type PictureEditorStrings = {
+    validate: string;
+};
+declare class PictureEditor extends LitElement {
+    rotation: number;
+    image: string;
+    strings: PictureEditorStrings;
+    private rotatedImageBase64?;
+    private rotatedImage?;
+    constructor();
+    static properties: {
+        image: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        rotation: {
+            attribute: string;
+            type: NumberConstructor;
+        };
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+    };
+    static styles: lit.CSSResult;
+    rotateImage(degrees: number): Promise<void>;
+    rotateLeft(): Promise<void>;
+    rotateRight(): Promise<void>;
+    emitValidation(): void;
+    firstUpdated(changes: PropertyValues$1<this>): Promise<void>;
+    render(): lit_html.TemplateResult<1>;
+    private createImage;
+    private blobToBase64;
+}
+
+type FileUploadStrings = {
+    badType: string;
+    maxSize: string;
+    text: string;
+};
+declare class FileUpload extends LitElement {
+    maxSize: number;
+    supportedTypes: string[];
+    strings: FileUploadStrings;
+    error: string;
+    inited: boolean;
+    constructor();
+    static properties: {
+        supportedTypes: {
+            attribute: string;
+            type: ArrayConstructor;
+        };
+        maxSize: {
+            attribute: string;
+            type: NumberConstructor;
+        };
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        error: {
+            state: boolean;
+        };
+        init: {
+            state: boolean;
+        };
+    };
+    validateFile(type: string, size: number): {
+        valid: boolean;
+        error: string;
+    };
+    handleFileSelection(files: FileList): void;
+    handleClick(): void;
+    init(): void;
+    updated(): void;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+
+type ImageCaptureDirectionsStrings = {
+    document: string;
+    face: string;
+    light: string;
+};
+declare class ImageCaptureDirections extends LitElement {
+    strings: ImageCaptureDirectionsStrings;
+    static properties: {
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+    };
+    static styles: lit.CSSResult[];
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class RecorderExt extends Recorder {
+}
+
+type Hint = "generic" | "mask" | "brightness" | "mask-brightness";
+type RetryResultStrings = {
+    default: string;
+    retryMessage: string;
+    retriesLeft: {
+        _1: string;
+        _2: string;
+        _3: string;
+    };
+    retryBtn: string;
+    finishBtn: string;
+    covideMask: string;
+    brightness: string;
+};
+declare class RetryResult extends LitElement {
+    hintKind: Hint;
+    retriesLeft: number;
+    strings: RetryResultStrings;
+    static properties: {
+        hintKind: {
+            attribute: string;
+            type: StringConstructor;
+        };
+        retriesLeft: {
+            attribute: string;
+            type: NumberConstructor;
+        };
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+    };
+    static styles: lit.CSSResult;
+    isMobile: boolean;
+    handleFinish(): void;
+    handleRetry(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+type CaptureStep$2 = "directions" | "record";
+declare const selfieCaptureStrings: {
+    back: string;
+    directionSubtitle: string;
+    recordBtnLabel: string;
+    title: string;
+    recordSubtitle: string;
+    acquisitionDuration: {
+        base: string;
+        singular: string;
+        plural: string;
+    };
+    directions: {
+        position: string;
+        face: string;
+        light: string;
+        camera: string;
+    };
+    recorder: {
+        capture: string;
+        retry: string;
+        errors: {
+            noFace: string;
+        };
+        hints: {
+            up: string;
+            down: string;
+            perfect: string;
+            right: string;
+            left: string;
+            closer: string;
+            record: string;
+            nil: string;
+        };
+        forbiddenActionMessages: {
+            visibility: string;
+            focus: string;
+            keyboard: string;
+            default: string;
+        };
+        cameraErrorMessages: {
+            permissionDenied: string;
+            openFailed: string;
+            default: string;
+        };
+        rotationWhileCapturingErrorMessage: string;
+        activeChallengeMessages: {
+            rotateLeft: string;
+            rotateRight: string;
+            rotateUp: string;
+            rotateDown: string;
+        };
+    };
+};
+type RecorderOptions$1 = Partial<{
+    preset: AcquisitionPreset$1;
+    logLevel: LogLevel$1;
+    config: Partial<SessionConfig$1>;
+    faceChecker: FaceChecker;
+    instructionMessages: InstructionMessage[];
+}>;
+declare class SelfieCapture extends LitElement {
+    captureStep: CaptureStep$2;
+    strings: Partial<typeof selfieCaptureStrings>;
+    recorderOptions: RecorderOptions$1;
+    hideCapturePrevBtn: boolean;
+    hideCaptureBtn: boolean;
+    acquisitionTime: number;
+    static properties: {
+        recorderOptions: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        hideCapturePrevBtn: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+        hideCaptureBtn: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+        captureStep: {
+            state: boolean;
+        };
+        acquisitionTime: {
+            state: boolean;
+        };
+    };
+    static styles: lit.CSSResult;
+    constructor();
+    handleBack(): void;
+    handleRecordStart(): void;
+    handleRecord(e: CustomEvent<{
+        media: Blob;
+        metadata: unknown;
+    }>): void;
+    handleRecoderReady(e: CustomEvent<{
+        mediaType: string;
+        acquisitionTime: number;
+    }>): void;
+    handleRecordCompleted(e: CustomEvent<{
+        media: Blob;
+        metadata: unknown;
+    }>): void;
+    handleRecordStarting(e: CustomEvent): void;
+    handleRecordCapturing(e: CustomEvent): void;
+    handleRecordInterrupted(e: CustomEvent): void;
+    renderDirections(): lit_html.TemplateResult<1>;
+    renderRecorder(): lit_html.TemplateResult<1>;
+    render(): lit_html.TemplateResult<1>;
+}
+
+type CaptureStep$1 = "directions" | "file-upload" | "picture-record" | "video-record" | "picture-editor" | "video-replay";
+type State = {
+    step: CaptureStep$1;
+    prevStep?: CaptureStep$1;
+    picture?: Blob;
+    video?: Blob;
+};
+type Actions = {
+    type: "display-directions";
+} | {
+    type: "display-file-upload";
+} | {
+    type: "display-picture-record";
+} | {
+    type: "display-video-record";
+} | {
+    type: "display-picture-editor";
+} | {
+    type: "display-video-replay";
+} | {
+    type: "set-video";
+    payload: {
+        video: Blob;
+    };
+} | {
+    type: "set-picture";
+    payload: {
+        picture: Blob;
+        source: "file-upload" | "picture-record";
+    };
+};
+declare const referenceCaptureStrings: {
+    back: string;
+    title: string;
+    captureTitle: string;
+    editorTitle: string;
+    directionSubtitle: string;
+    pictureRecordSubtitle: string;
+    videoRecordSubtitle: string;
+    uploadBtn: string;
+    pictureBtn: string;
+    recordVidBtn: string;
+    retryPictureCaptureBtn: string;
+    retryVideoCaptureBtn: string;
+    replayValidation: string;
+    editor: {
+        validate: string;
+    };
+    directions: {
+        document: string;
+        face: string;
+        light: string;
+    };
+    videoRecorder: {
+        capture: string;
+        retry: string;
+        errors: {
+            noFace: string;
+        };
+        hints: {
+            up: string;
+            down: string;
+            perfect: string;
+            right: string;
+            left: string;
+            closer: string;
+            record: string;
+            nil: string;
+        };
+        forbiddenActionMessages: {
+            visibility: string;
+            focus: string;
+            keyboard: string;
+            default: string;
+        };
+        cameraErrorMessages: {
+            permissionDenied: string;
+            openFailed: string;
+            default: string;
+        };
+        rotationWhileCapturingErrorMessage: string;
+        activeChallengeMessages: {
+            rotateLeft: string;
+            rotateRight: string;
+            rotateUp: string;
+            rotateDown: string;
+        };
+    };
+    pictureRecorder: {
+        capture: string;
+    };
+    fileUpload: {
+        badType: string;
+        maxSize: string;
+        text: string;
+    };
+};
+type RecorderOptions = Partial<{
+    logLevel: LogLevel$1;
+}>;
+declare class ReferenceCapture extends LitElement {
+    constructor();
+    state: State;
+    strings: Partial<typeof referenceCaptureStrings>;
+    recorderOptions: RecorderOptions;
+    hideCaptureBtn: boolean;
+    static properties: {
+        recorderOptions: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        hideCaptureBtn: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+        state: {
+            state: boolean;
+        };
+    };
+    static styles: lit.CSSResult;
+    handleFileSelection(e: CustomEvent<{
+        file: File;
+    }>): void;
+    handlePictureCapture(e: CustomEvent<{
+        picture: Blob;
+    }>): void;
+    dispatch(action: Actions): void;
+    displayUploadStep(): void;
+    displayPictureRecordStep(): void;
+    displayVideoRecordStep(): void;
+    displayDirectionsStep(): void;
+    retryCapture(): void;
+    handlePicture(e: CustomEvent<{
+        picture: Blob;
+    }>): void;
+    handleVideo(): void;
+    handleVideoRecord(e: CustomEvent<{
+        media: Blob;
+        meta: unknown;
+    }>): void;
+    handleVideoRecoderReady(e: CustomEvent<{
+        mediaType: string;
+        acquisitionTime: number;
+    }>): void;
+    handlePictureRecoderReady(e: CustomEvent<{
+        mediaType: string;
+        acquisitionTime: number;
+    }>): void;
+    handleRecordCompleted(e: CustomEvent<{
+        media: Blob;
+        metadata: unknown;
+    }>): void;
+    handleRecordStarting(e: CustomEvent): void;
+    handleRecordCapturing(e: CustomEvent): void;
+    handleRecordInterrupted(e: CustomEvent): void;
+    renderDirections(): lit_html.TemplateResult<1>;
+    renderFileUpload(): lit_html.TemplateResult<1>;
+    renderPictureEditor(): lit_html.TemplateResult<1>;
+    renderPictureRecord(): lit_html.TemplateResult<1>;
+    renderVideoRecord(): lit_html.TemplateResult<1>;
+    renderVideoReplay(): lit_html.TemplateResult<1>;
+    render(): lit_html.TemplateResult<1>;
+}
+
+type CaptureStep = "reference" | "selfie";
+declare const fullCaptureStrings: {
+    reference: {
+        back: string;
+        title: string;
+        captureTitle: string;
+        editorTitle: string;
+        directionSubtitle: string;
+        pictureRecordSubtitle: string;
+        videoRecordSubtitle: string;
+        uploadBtn: string;
+        pictureBtn: string;
+        recordVidBtn: string;
+        retryPictureCaptureBtn: string;
+        retryVideoCaptureBtn: string;
+        replayValidation: string;
+        editor: {
+            validate: string;
+        };
+        directions: {
+            document: string;
+            face: string;
+            light: string;
+        };
+        videoRecorder: {
+            capture: string;
+            retry: string;
+            errors: {
+                noFace: string;
+            };
+            hints: {
+                up: string;
+                down: string;
+                perfect: string;
+                right: string;
+                left: string;
+                closer: string;
+                record: string;
+                nil: string;
+            };
+            forbiddenActionMessages: {
+                visibility: string;
+                focus: string;
+                keyboard: string;
+                default: string;
+            };
+            cameraErrorMessages: {
+                permissionDenied: string;
+                openFailed: string;
+                default: string;
+            };
+            rotationWhileCapturingErrorMessage: string;
+            activeChallengeMessages: {
+                rotateLeft: string;
+                rotateRight: string;
+                rotateUp: string;
+                rotateDown: string;
+            };
+        };
+        pictureRecorder: {
+            capture: string;
+        };
+        fileUpload: {
+            badType: string;
+            maxSize: string;
+            text: string;
+        };
+    };
+    selfie: {
+        back: string;
+        directionSubtitle: string;
+        recordBtnLabel: string;
+        title: string;
+        recordSubtitle: string;
+        acquisitionDuration: {
+            base: string;
+            singular: string;
+            plural: string;
+        };
+        directions: {
+            position: string;
+            face: string;
+            light: string;
+            camera: string;
+        };
+        recorder: {
+            capture: string;
+            retry: string;
+            errors: {
+                noFace: string;
+            };
+            hints: {
+                up: string;
+                down: string;
+                perfect: string;
+                right: string;
+                left: string;
+                closer: string;
+                record: string;
+                nil: string;
+            };
+            forbiddenActionMessages: {
+                visibility: string;
+                focus: string;
+                keyboard: string;
+                default: string;
+            };
+            cameraErrorMessages: {
+                permissionDenied: string;
+                openFailed: string;
+                default: string;
+            };
+            rotationWhileCapturingErrorMessage: string;
+            activeChallengeMessages: {
+                rotateLeft: string;
+                rotateRight: string;
+                rotateUp: string;
+                rotateDown: string;
+            };
+        };
+    };
+};
+declare class FullCapture extends LitElement {
+    constructor();
+    captureStep: CaptureStep;
+    reference: Blob;
+    strings: Partial<typeof fullCaptureStrings>;
+    recorderOptions: RecorderOptions$1;
+    hideSelfieCaptureBtn: boolean;
+    hideReferenceCaptureBtn: boolean;
+    static properties: {
+        recorderOptions: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        strings: {
+            attribute: string;
+            type: ObjectConstructor;
+        };
+        hideSelfieCaptureBtn: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+        hideReferenceCaptureBtn: {
+            attribute: string;
+            type: BooleanConstructor;
+        };
+        captureStep: {
+            state: boolean;
+        };
+    };
+    handleReference(e: CustomEvent<{
+        media: Blob;
+    }>): void;
+    handleSelfie(e: CustomEvent<{
+        media: Blob;
+        metadata: unknown;
+    }>): void;
+    handleRecoderReady(e: CustomEvent<{
+        recorderElmt: HTMLElement;
+        mediaType: string;
+        contentKind: string;
+        acquisitionTime?: number;
+    }>): void;
+    handleBack(): void;
+    renderReferenceStep(): lit_html.TemplateResult<1>;
+    renderSelfieStep(): lit_html.TemplateResult<1>;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare const FR: I18n;
+
+declare enum AcquisitionPreset {
+    SELFIE_FAST = "selfie-fast",
+    SELFIE_SUBSTANTIAL = "selfie-substantial",
+    SELFIE_OPTIMIZED = "selfie-optimized",
+    NO_RECORD = "no-record",
+    DOC_VIDEO = "doc-video",
+    DOC_IMAGE = "doc-image"
+}
+declare enum IadMode {
+    DISABLED = "disabled",
+    PASSIVE = "passive",
+    PASSIVE_LT = "passive-lt",
+    ACTIVE_FALLBACK = "active-fallback",
+    ACTIVE = "active"
+}
+type IadConfig = {
+    mode: IadMode;
+    data?: string;
+    retryCount?: number;
+    activeChallengeConfig?: ActiveChallengeConfig;
+};
+type ActiveChallengeConfig = {
+    numberOfActions?: number;
+    maxSecondsBetweenActions?: number;
+};
+type VideoLength = {
+    type: "duration";
+    durationMs: number;
+} | {
+    type: "frame-count";
+    frameCount: number;
+};
+interface RecordingConfig {
+    audio: boolean;
+    bitRateKbps: number;
+    length: VideoLength;
+}
+type ColorRGBA = [number, number, number, number];
+type OverlayColors = Record<"background" | "innerBorder" | "progressColor", ColorRGBA>;
+declare enum OverlayDisplayMode {
+    OVAL = "oval",
+    RECT_PORTRAIT = "rect-portrait",
+    RECT_LANDSCAPE = "rect-landscape",
+    DEBUG_FRAME = "debug-frame",
+    ID_DOCUMENT = "id-document"
+}
+type OverlayConfig = {
+    displayMode: OverlayDisplayMode;
+    colors: OverlayColors;
+};
+declare enum VideoOrientation {
+    LANDSCAPE = "landscape",
+    PORTRAIT = "portrait"
+}
+declare enum LogLevel {
+    QUIET = 0,
+    WARNING = 1,
+    INFO = 2,
+    VERBOSE = 3,
+    PERFORMANCE = 4
+}
+declare enum VideoResolutionPreset {
+    NO_SPECIFIC_RESOLUTION = "no-specific-resolution",
+    STD_480P = "720x480",
+    STD_720P = "1280x720",
+    STD_1080P = "1920x1080",
+    STD_2160P = "3840x2160",
+    STD_4320P = "7680x4320",
+    STD_VGA = "640x480",
+    STD_SVGA = "800x600",
+    STD_XVGA = "1024x768",
+    SQUARE_600P = "600x600"
+}
+declare enum FacingMode {
+    FRONT = "user",
+    BACK = "environment"
+}
+interface CameraConfig {
+    preferredFps: number;
+    preferredResolution: VideoResolutionPreset;
+    preferredOrientation: VideoOrientation;
+    facingMode: FacingMode;
+}
+interface SessionConfig {
+    overlayConfig?: Partial<OverlayConfig>;
+    cameraConfig?: Partial<CameraConfig>;
+    recordingConfig?: Partial<RecordingConfig>;
+    iadConfig?: IadConfig;
+    versions?: {
+        [name: string]: string;
+    };
+}
+
+export { AcquisitionPreset, ActiveChallengeConfig, Button, CameraConfig, CameraVideoOutlinedIcon, ColorRGBA, DirectionCard, EN, FR, FaceChecker, FacingMode, FileUpload, FullCapture, IadConfig, IadMode, ImageCaptureDirections, InstructionMessage, LogLevel, OverlayColors, OverlayConfig, OverlayDisplayMode, OverlayHints, PictureEditor, PictureRecorder, Recorder, RecorderExt, RecorderOptions$1 as RecorderOptions, RecordingConfig, ReferenceCapture, RetryResult, SelfieCapture, SessionConfig, VideoLength, VideoOrientation, VideoRecordDirections, VideoResolutionPreset };