@ahmed_hani/dot-auto-capture-ui 7.4.0

package/ui/src/types/document.d.ts

@@ -0,0 +1,38 @@
+import type { BaseComponentsUiProps, CustomizationContextProps, EscalatedInstructions, HTMLElementWithProps, UiProps } from './common';
+import type { CustomElement, DeepRequired, DocumentEscalatedInstructionCodes, DocumentInstructionCode, ObjectValues } from '../../../ui-common/src/types';
+export * from './common';
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'x-dot-document-auto-capture-ui': CustomElement<{
+                props: DocumentUiProps;
+            }>;
+        }
+    }
+    namespace React.JSX {
+        interface IntrinsicElements {
+            'x-dot-document-auto-capture-ui': CustomElement<{
+                props: DocumentUiProps;
+            }>;
+        }
+    }
+}
+export declare const DocumentPlaceholderIconValues: {
+    readonly ID_CORNERS: "id-corners";
+    readonly ID_DASH: "id-dash";
+    readonly ID_DOT: "id-dot";
+    readonly ID_SOLID: "id-solid";
+    readonly ID_PHOTO_ROUNDED: "id-photo-rounded";
+    readonly ID_CORNERS_ROUNDED: "id-corners-rounded";
+    readonly ID_DASH_ROUNDED: "id-dash-rounded";
+    readonly ID_DOT_ROUNDED: "id-dot-rounded";
+    readonly ID_SOLID_ROUNDED_BACK: "id-solid-rounded-back";
+    readonly ID_SOLID_ROUNDED: "id-solid-rounded";
+    readonly PASSPORT_SOLID_BACK: "passport-solid-back";
+    readonly PASSPORT_SOLID_BACK_BLANK: "passport-solid-back-blank";
+};
+export type DocumentPlaceholderIcon = ObjectValues<typeof DocumentPlaceholderIconValues>;
+export type DocumentInstructions = Record<DocumentInstructionCode, string>;
+export type DocumentUiProps = UiProps<Partial<DocumentInstructions>> & BaseComponentsUiProps<DocumentPlaceholderIcon> & EscalatedInstructions<DocumentEscalatedInstructionCodes>;
+export type DocumentProps = CustomizationContextProps<DeepRequired<DocumentUiProps>> & EscalatedInstructions<DocumentEscalatedInstructionCodes>;
+export type HTMLDocumentUiElement = HTMLElementWithProps<DocumentUiProps>;

package/ui/src/types/eye-gaze.d.ts

@@ -0,0 +1,37 @@
+import type { AppStateInstruction, BaseComponentsUiProps, CustomizationContextProps, HTMLElementWithProps, UiProps } from './common';
+import type { CornerValues, CustomElement, DeepRequired, EyeGazeInstructionCode } from '../../../ui-common/src/types';
+export * from './common';
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'x-dot-eye-gaze-liveness-ui': CustomElement<{
+                props: EyeGazeLivenessUiProps;
+            }>;
+        }
+    }
+    namespace React.JSX {
+        interface IntrinsicElements {
+            'x-dot-eye-gaze-liveness-ui': CustomElement<{
+                props: EyeGazeLivenessUiProps;
+            }>;
+        }
+    }
+}
+export type EyeGazeInstructions = Record<EyeGazeInstructionCode, string>;
+type CustomizableInstructions = Omit<EyeGazeInstructions, 'mouth_score_too_high' | 'mouth_score_too_low'>;
+export type EyeGazeLivenessUiProps<I = CustomizableInstructions, SI = EyeGazeStateInstructions> = UiProps<I, SI> & Omit<BaseComponentsUiProps<string>, 'placeholder'> & {
+    collectionPhasePlaceholder?: string;
+    corners: Array<CornerValues>;
+};
+type RequiredUiProps = DeepRequired<EyeGazeLivenessUiProps<EyeGazeInstructions>>;
+export type EyeGazeProps = CustomizationContextProps<RequiredUiProps> & {
+    collectionPhasePlaceholder: string;
+};
+export type HTMLEyeGazeLivenessUiElement = HTMLElementWithProps<EyeGazeLivenessUiProps>;
+export type EyeGazeStateInstructions = {
+    done?: AppStateInstruction;
+    loading?: AppStateInstruction;
+};
+export type UiEyeGazeStateInstructions = {
+    [key: string]: DeepRequired<AppStateInstruction>;
+};

package/ui/src/types/face.d.ts

@@ -0,0 +1,45 @@
+import type { BaseComponentsUiProps, CustomizationContextProps, HTMLElementWithProps, UiProps } from './common';
+import type { CustomElement, DeepRequired, FaceInstructionCode, ObjectValues } from '../../../ui-common/src/types';
+export * from './common';
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'x-dot-face-auto-capture-ui': CustomElement<{
+                props: FaceUiProps;
+            }>;
+        }
+    }
+    namespace React.JSX {
+        interface IntrinsicElements {
+            'x-dot-face-auto-capture-ui': CustomElement<{
+                props: FaceUiProps;
+            }>;
+        }
+    }
+}
+export declare const FacePlaceholderIconValues: {
+    readonly CIRCLE_SOLID: "circle-solid";
+    /**
+     * @deprecated This placeholder will be removed in future release.
+     */
+    readonly ELLIPSE_SOLID: "ellipse-solid";
+    /**
+     * @deprecated This placeholder will be removed in future release.
+     */
+    readonly MAN_SOLID: "man-solid";
+    /**
+     * @deprecated This placeholder will be removed in future release.
+     */
+    readonly WOMAN_SOLID: "woman-solid";
+    readonly SQUARE_ROUNDED_DASH: "square-rounded-dash";
+    readonly SQUARE_ROUNDED_SOLID: "square-rounded-solid";
+    readonly SQUARE_DASH: "square-dash";
+    readonly SQUARE_SOLID: "square-solid";
+};
+export type FacePlaceholderIcon = ObjectValues<typeof FacePlaceholderIconValues>;
+export type FaceInstructions = Record<FaceInstructionCode, string>;
+export type CustomizableFaceInstructions = Omit<FaceInstructions, 'mouth_score_too_low' | 'mouth_score_too_high'>;
+export type FaceUiProps<I = CustomizableFaceInstructions> = UiProps<I> & BaseComponentsUiProps<FacePlaceholderIcon>;
+type RequiredUiProps = DeepRequired<FaceUiProps<FaceInstructions>>;
+export type FaceProps = CustomizationContextProps<RequiredUiProps>;
+export type HTMLFacetUiElement = HTMLElementWithProps<FaceUiProps>;

package/ui/src/types/magnifeye.d.ts

@@ -0,0 +1,32 @@
+import type { AppStateInstruction, CustomizationContextProps, HTMLElementWithProps, UiProps } from './common';
+import type { CustomElement, DeepRequired, MagnifEyeInstructionCode } from '../../../ui-common/src/types';
+export * from './common';
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'x-dot-magnifeye-liveness-ui': CustomElement<{
+                props: MagnifEyeLivenessUiProps;
+            }>;
+        }
+    }
+    namespace React.JSX {
+        interface IntrinsicElements {
+            'x-dot-magnifeye-liveness-ui': CustomElement<{
+                props: MagnifEyeLivenessUiProps;
+            }>;
+        }
+    }
+}
+export type MagnifEyeInstructions = Record<MagnifEyeInstructionCode, string>;
+export type CustomizableMagnifEyeInstructions = Omit<MagnifEyeInstructions, 'mouth_score_too_high' | 'mouth_score_too_low'>;
+export type MagnifEyeLivenessUiProps<I = CustomizableMagnifEyeInstructions, SI = MagnifEyeStateInstructions> = UiProps<I, SI>;
+type RequiredUiProps = DeepRequired<UiProps<MagnifEyeInstructions>>;
+export type MagnifEyeProps = CustomizationContextProps<RequiredUiProps>;
+export type HTMLMagnifEyeLivenessUiElement = HTMLElementWithProps<MagnifEyeLivenessUiProps>;
+export type MagnifEyeStateInstructions = {
+    done?: AppStateInstruction;
+    loading?: AppStateInstruction;
+};
+export type UiMagnifEyeStateInstructions = {
+    [key: string]: DeepRequired<AppStateInstruction>;
+};

package/ui/src/types/palm.d.ts

@@ -0,0 +1,27 @@
+import type { BaseComponentsUiProps, CustomizationContextProps, HTMLElementWithProps, UiProps } from './common';
+import type { CustomElement, DeepRequired, ObjectValues, PalmInstructionCode } from '../../../ui-common/src/types';
+export * from './common';
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'x-dot-palm-capture-ui': CustomElement<{
+                props: PalmUiProps;
+            }>;
+        }
+    }
+    namespace React.JSX {
+        interface IntrinsicElements {
+            'x-dot-palm-capture-ui': CustomElement<{
+                props: PalmUiProps;
+            }>;
+        }
+    }
+}
+export declare const PalmPlaceholderIconValues: {
+    readonly WITHOUT_FINGERS: "withoutFingers";
+};
+export type PalmPlaceholderIcon = ObjectValues<typeof PalmPlaceholderIconValues>;
+export type PalmInstructions = Record<PalmInstructionCode, string>;
+export type PalmUiProps = UiProps<Partial<PalmInstructions>> & BaseComponentsUiProps<PalmPlaceholderIcon>;
+export type PalmProps = CustomizationContextProps<DeepRequired<PalmUiProps>>;
+export type HTMLPalmUiElement = HTMLElementWithProps<PalmUiProps>;

package/ui/src/types/smile.d.ts

@@ -0,0 +1,32 @@
+import type { AppStateInstruction, CustomizationContextProps, EscalatedInstructions, HTMLElementWithProps, UiProps } from './common';
+import type { CustomElement, DeepRequired, SmileEscalatedInstructionCodes, SmileInstructionCode } from '../../../ui-common/src/types';
+export * from './common';
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'x-dot-smile-liveness-ui': CustomElement<{
+                props: SmileLivenessUiProps;
+            }>;
+        }
+    }
+    namespace React.JSX {
+        interface IntrinsicElements {
+            'x-dot-smile-liveness-ui': CustomElement<{
+                props: SmileLivenessUiProps;
+            }>;
+        }
+    }
+}
+export type SmileInstructions = Record<SmileInstructionCode, string>;
+export type CustomizableSmileInstructions = Omit<SmileInstructions, 'mouth_score_too_high' | 'mouth_score_too_low'>;
+export type SmileLivenessUiProps<I = CustomizableSmileInstructions, SI = SmileStateInstructions> = UiProps<I, SI> & EscalatedInstructions<SmileEscalatedInstructionCodes>;
+type RequiredUiProps = DeepRequired<UiProps<SmileInstructions>>;
+export type SmileProps = CustomizationContextProps<RequiredUiProps> & EscalatedInstructions<SmileEscalatedInstructionCodes>;
+export type HTMLSmileLivenessUiElement = HTMLElementWithProps<SmileLivenessUiProps>;
+export type SmileStateInstructions = {
+    done?: AppStateInstruction;
+    loading?: AppStateInstruction;
+};
+export type UiSmileStateInstructions = {
+    [key: string]: DeepRequired<AppStateInstruction>;
+};

package/ui-common/src/error/auto-capture-error.d.ts

@@ -0,0 +1,7 @@
+export declare class AutoCaptureError extends Error {
+    cause: Error | undefined;
+    constructor(message: string, cause?: Error);
+    static logError(error: unknown): void;
+    static fromCameraError(error: Error): AutoCaptureError;
+    static fromError(error: unknown): AutoCaptureError;
+}

package/ui-common/src/error/index.d.ts

@@ -0,0 +1 @@
+export * from './auto-capture-error';

package/ui-common/src/types/common.d.ts

@@ -0,0 +1,88 @@
+type CustomEvents<K extends string> = {
+    [key in K]: (event: CustomEvent) => void;
+};
+export type CustomElement<T, K extends string = ''> = Partial<T & HTMLElement & {
+    children: unknown;
+} & CustomEvents<`on${K}`> & {
+    ref?: unknown;
+}>;
+export type DeepRequired<T> = Required<{
+    [P in keyof T]: T[P] extends Record<string, unknown> | undefined ? DeepRequired<Required<T[P]>> : T[P];
+}>;
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type RequireSome<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type ObjectValues<T> = T[keyof T];
+export declare const FacingMode: {
+    readonly FRONT: "user";
+    readonly REAR: "environment";
+};
+export type FacingModeValues = ObjectValues<typeof FacingMode>;
+export declare const CaptureMode: {
+    readonly AUTO_CAPTURE: "AUTO_CAPTURE";
+    readonly WAIT_FOR_REQUEST: "WAIT_FOR_REQUEST";
+};
+export type CaptureModeValues = ObjectValues<typeof CaptureMode>;
+export type BaseCameraProps<CallbackData> = {
+    assetsDirectoryPath?: string;
+    cameraFacing?: FacingModeValues;
+    candidateSelectionDurationMillis?: number;
+    captureMode?: CaptureModeValues;
+    onError: (e: Error) => void;
+    onPhotoTaken: (imageData: CallbackImage<CallbackData>, content: Uint8Array) => void;
+    sessionToken?: string;
+    styleTarget?: HTMLElement;
+};
+export type ImageParameters = {
+    brightness: number;
+    sharpness: number;
+};
+export type CameraSettings = MediaTrackSettings & {
+    deviceName?: string;
+};
+export type Resolution = {
+    height: number;
+    width: number;
+};
+export type Point = {
+    x: number;
+    y: number;
+};
+export declare const AppStateValues: {
+    readonly LOADING: "LOADING";
+    readonly ERROR: "ERROR";
+    readonly WAITING: "WAITING";
+    readonly RUNNING: "RUNNING";
+};
+export declare const LivenessStateValues: {
+    readonly DONE: "DONE";
+    readonly LOADING: "LOADING";
+    readonly ERROR: "ERROR";
+    readonly WAITING: "WAITING";
+    readonly RUNNING: "RUNNING";
+};
+export type AppState = ObjectValues<typeof AppStateValues>;
+export type Crop = {
+    height: number;
+    shiftX: number;
+    shiftY: number;
+    width: number;
+};
+export type CallbackImage<T> = {
+    data: T;
+    image: Blob;
+};
+export type DetectedCorners = {
+    bottomLeft: Point;
+    bottomRight: Point;
+    topLeft: Point;
+    topRight: Point;
+};
+export type ThresholdInterval = {
+    max: number;
+    min: number;
+};
+export {};

package/ui-common/src/types/document.d.ts

@@ -0,0 +1,30 @@
+import type { DetectedCorners, ImageParameters, ObjectValues } from './common';
+export declare const DocumentInstructionCodeValues: {
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly DOCUMENT_CENTERING: "document_centering";
+    readonly DOCUMENT_NOT_PRESENT: "document_not_present";
+    readonly DOCUMENT_TOO_FAR: "document_too_far";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly HOTSPOTS_PRESENT: "hotspots_present";
+};
+export declare const DocumentCheckToInstructionCodeMap: {
+    isPresent: "document_not_present";
+    isNotSmall: "document_too_far";
+    isNotOutOfBounds: "document_centering";
+    isSharp: "sharpness_too_low";
+    isNotDim: "brightness_too_low";
+    isNotBright: "brightness_too_high";
+    noHotspots: "hotspots_present";
+};
+export type DocumentInstructionCode = ObjectValues<typeof DocumentInstructionCodeValues>;
+export type DetectedDocumentCorners = DetectedCorners;
+export type DocumentImageParameters = ImageParameters & {
+    hotspots: number;
+};
+export type DetectedDocument = DocumentImageParameters & DetectedDocumentCorners & {
+    confidence: number;
+    smallestEdge: number;
+};
+export type DocumentEscalatedInstructionCodes = typeof DocumentInstructionCodeValues.DOCUMENT_TOO_FAR | typeof DocumentInstructionCodeValues.BRIGHTNESS_TOO_HIGH | typeof DocumentInstructionCodeValues.BRIGHTNESS_TOO_LOW | typeof DocumentInstructionCodeValues.SHARPNESS_TOO_LOW;

package/ui-common/src/types/events/common.d.ts

@@ -0,0 +1,74 @@
+import type { DocumentCustomEvent } from './document';
+import type { FaceCustomEvent } from './face';
+import type { PalmCustomEvent } from './palm';
+import type { AutoCaptureError } from '../../error/auto-capture-error';
+import type { AppState, ObjectValues, Resolution } from '../common';
+import type { DocumentInstructionCode } from '../document';
+import type { FaceInstructionCode } from '../face';
+import type { PalmInstructionCode } from '../palm';
+export declare const ControlEventInstruction: {
+    readonly CONTINUE_DETECTION: "continue-detection";
+    readonly SWITCH_CAMERA: "switch-camera";
+    readonly TOGGLE_MIRROR: "toggle-mirror";
+};
+export type ControlEventInstructionValues = ObjectValues<typeof ControlEventInstruction>;
+export declare const RequestCaptureInstruction: {
+    readonly FIRST_FRAME: "first-frame";
+    readonly FIRST_VALID_FRAME: "first-valid-frame";
+};
+export type RequestCaptureInstructionValues = ObjectValues<typeof RequestCaptureInstruction>;
+export declare const ComponentCustomEvent: {
+    readonly REQUEST_CAPTURE: "dot-custom-event:request-capture";
+};
+export type ComponentCustomEventValues = ObjectValues<typeof ComponentCustomEvent>;
+export type ControlEvent<T> = {
+    detail?: {
+        instruction: T;
+    };
+} & Event;
+export type CameraPropsChangeEvent = {
+    detail?: {
+        cameraResolution: Resolution;
+        isMirroring: boolean;
+    };
+} & Event;
+export type CameraStateChangeEvent = {
+    detail?: {
+        appState: AppState;
+        error?: AutoCaptureError;
+    };
+} & Event;
+export type InstructionChangeEvent<T> = {
+    detail?: {
+        instructionCode: T;
+        isEscalated: boolean;
+    };
+} & Event;
+export type InstructionEscalatedEvent<T> = {
+    detail?: {
+        instructionCode: T;
+    };
+} & Event;
+export type InstructionChangeEventCodeMap = {
+    [DocumentCustomEvent.INSTRUCTION_CHANGED]: DocumentInstructionCode;
+    [FaceCustomEvent.INSTRUCTION_CHANGED]: FaceInstructionCode;
+    [PalmCustomEvent.INSTRUCTION_CHANGED]: PalmInstructionCode;
+};
+export type CaptureCustomEvent = typeof PalmCustomEvent | typeof DocumentCustomEvent | typeof FaceCustomEvent;
+export type VideoElementSizeChangeEvent = {
+    detail?: {
+        size: DOMRect;
+    };
+} & Event;
+export type DetectionEvent<TDetectedObject, TInstructionCode extends string = string> = {
+    detail?: {
+        data: {
+            detection: TDetectedObject;
+            fps: number;
+            imageResolution: Resolution;
+            invalidValidators: Array<TInstructionCode>;
+            isInCandidateSelection: boolean;
+        };
+        image: HTMLCanvasElement;
+    };
+} & Event;

package/ui-common/src/types/events/document.d.ts

@@ -0,0 +1,23 @@
+import type { InstructionChangeEvent, InstructionEscalatedEvent } from './common';
+import type { DetectedDocument, DocumentInstructionCode } from '../document';
+export declare enum DocumentCustomEvent {
+    CAMERA_PROPS_CHANGED = "document-auto-capture:camera-props-changed",
+    CONTROL = "document-auto-capture:control",
+    DETECTED_DOCUMENT_CHANGED = "document-auto-capture:detected-document-changed",
+    DOCUMENT_DETECTION = "document-auto-capture:document-detection",
+    INSTRUCTION_CHANGED = "document-auto-capture:instruction-changed",
+    INSTRUCTION_ESCALATED = "document-auto-capture:instruction-escalated",
+    STATE_CHANGED = "document-auto-capture:state-changed",
+    VIDEO_ELEMENT_SIZE = "document-auto-capture:video-element-size"
+}
+export type DetectedDocumentChangeEvent = {
+    detail?: {
+        detectedObject: DetectedDocument;
+    };
+} & Event;
+export type DocumentInstructionChangeEvent = InstructionChangeEvent<DocumentInstructionCode>;
+export type DispatchDocumentDetectionEvent = {
+    detection: DetectedDocument;
+    eventName: DocumentCustomEvent.DOCUMENT_DETECTION;
+};
+export type DocumentInstructionEscalatedEvent = InstructionEscalatedEvent<DocumentInstructionCode>;

package/ui-common/src/types/events/eye-gaze.d.ts

@@ -0,0 +1,4 @@
+export declare enum EyeGazeCustomEvent {
+    CONTROL = "eye-gaze-auto-capture:control",
+    STATUS_CHANGED = "eye-gaze-auto-capture:status-changed"
+}

package/ui-common/src/types/events/face.d.ts

@@ -0,0 +1,21 @@
+import type { InstructionChangeEvent } from './common';
+import type { DetectedFace, FaceInstructionCode } from '../face';
+export declare enum FaceCustomEvent {
+    CAMERA_PROPS_CHANGED = "face-auto-capture:camera-props-changed",
+    CONTROL = "face-auto-capture:control",
+    DETECTED_FACE_CHANGED = "face-auto-capture:detected-face-changed",
+    FACE_DETECTION = "face-auto-capture:face-detection",
+    INSTRUCTION_CHANGED = "face-auto-capture:instruction-changed",
+    STATE_CHANGED = "face-auto-capture:state-changed",
+    VIDEO_ELEMENT_SIZE = "face-auto-capture:video-element-size"
+}
+export type DetectedFaceChangeEvent = {
+    detail?: {
+        detectedObject: DetectedFace;
+    };
+} & Event;
+export type FaceInstructionChangeEvent = InstructionChangeEvent<FaceInstructionCode>;
+export type DispatchFaceDetectionEvent = {
+    detection: DetectedFace;
+    eventName: FaceCustomEvent.FACE_DETECTION;
+};

package/ui-common/src/types/events/index.d.ts

@@ -0,0 +1,8 @@
+export * from './common';
+export * from './document';
+export * from './face';
+export * from './magnifeye';
+export * from './liveness';
+export * from './smile';
+export * from './palm';
+export * from './eye-gaze';

package/ui-common/src/types/events/liveness.d.ts

@@ -0,0 +1,13 @@
+import type { AutoCaptureError } from '../../error';
+export type AnimationEndEvent = {
+    detail?: {
+        animationEnd: boolean;
+    };
+} & Event;
+export type StatusChangeEvent<Phase, State> = {
+    detail?: {
+        error?: AutoCaptureError;
+        phase?: Phase;
+        state?: State;
+    };
+} & Event;

package/ui-common/src/types/events/magnifeye.d.ts

@@ -0,0 +1,5 @@
+export declare enum MagnifEyeCustomEvent {
+    ANIMATION_END = "magnifeye-auto-capture:animation-end",
+    CONTROL = "magnifeye-auto-capture:control",
+    STATUS_CHANGED = "magnifeye-auto-capture:status-changed"
+}

package/ui-common/src/types/events/palm.d.ts

@@ -0,0 +1,16 @@
+import type { InstructionChangeEvent } from './common';
+import type { DetectedPalm, PalmInstructionCode } from '../palm';
+export declare enum PalmCustomEvent {
+    CAMERA_PROPS_CHANGED = "palm-capture:camera-props-changed",
+    CONTROL = "palm-capture:control",
+    DETECTED_PALM_CHANGED = "palm-capture:detected-palm-changed",
+    INSTRUCTION_CHANGED = "palm-capture:instruction-changed",
+    STATE_CHANGED = "palm-capture:state-changed",
+    VIDEO_ELEMENT_SIZE = "palm-capture:video-element-size"
+}
+export type DetectedPalmChangeEvent = {
+    detail?: {
+        detectedObject: DetectedPalm;
+    };
+} & Event;
+export type PalmInstructionChangeEvent = InstructionChangeEvent<PalmInstructionCode>;

package/ui-common/src/types/events/smile.d.ts

@@ -0,0 +1,8 @@
+import type { InstructionEscalatedEvent } from './common';
+import type { SmileInstructionCode } from '../smile';
+export declare enum SmileCustomEvent {
+    CONTROL = "smile-auto-capture:control",
+    INSTRUCTION_ESCALATED = "smile:instruction-escalated",
+    STATUS_CHANGED = "smile-auto-capture:status-changed"
+}
+export type SmileInstructionEscalatedEvent = InstructionEscalatedEvent<SmileInstructionCode>;

package/ui-common/src/types/eye-gaze.d.ts

@@ -0,0 +1,39 @@
+import type { ObjectValues } from './common';
+export declare const EyeGazeInstructionCodeValues: {
+    readonly WATCH_THE_OBJECT: "watch_the_object";
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly FACE_TOO_CLOSE: "face_too_close";
+    readonly FACE_TOO_FAR: "face_too_far";
+    readonly FACE_CENTERING: "face_centering";
+    readonly FACE_NOT_PRESENT: "face_not_present";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly DEVICE_PITCHED: "device_pitched";
+    readonly LEFT_EYE_NOT_PRESENT: "left_eye_not_present";
+    readonly RIGHT_EYE_NOT_PRESENT: "right_eye_not_present";
+    readonly MOUTH_NOT_PRESENT: "mouth_not_present";
+    readonly MOUTH_SCORE_TOO_HIGH: "mouth_score_too_high";
+    readonly MOUTH_SCORE_TOO_LOW: "mouth_score_too_low";
+};
+export type EyeGazeInstructionCode = ObjectValues<typeof EyeGazeInstructionCodeValues>;
+export declare const EyeGazePhaseValues: {
+    readonly VALIDATION: "VALIDATION";
+    readonly COLLECTION: "COLLECTION";
+};
+export type EyeGazePhase = ObjectValues<typeof EyeGazePhaseValues>;
+export declare const EyeGazeStateValues: {
+    readonly DONE: "DONE";
+    readonly LOADING: "LOADING";
+    readonly ERROR: "ERROR";
+    readonly WAITING: "WAITING";
+    readonly RUNNING: "RUNNING";
+};
+export type EyeGazeState = ObjectValues<typeof EyeGazeStateValues>;
+export declare const Corner: {
+    readonly TOP_LEFT: "TOP_LEFT";
+    readonly TOP_RIGHT: "TOP_RIGHT";
+    readonly BOTTOM_RIGHT: "BOTTOM_RIGHT";
+    readonly BOTTOM_LEFT: "BOTTOM_LEFT";
+};
+export type CornerValues = ObjectValues<typeof Corner>;

package/ui-common/src/types/face.d.ts

@@ -0,0 +1,52 @@
+import type { ImageParameters, ObjectValues, Point } from './common';
+export declare const FaceInstructionCodeValues: {
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly FACE_TOO_CLOSE: "face_too_close";
+    readonly FACE_TOO_FAR: "face_too_far";
+    readonly FACE_CENTERING: "face_centering";
+    readonly FACE_NOT_PRESENT: "face_not_present";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly DEVICE_PITCHED: "device_pitched";
+    readonly LEFT_EYE_NOT_PRESENT: "left_eye_not_present";
+    readonly RIGHT_EYE_NOT_PRESENT: "right_eye_not_present";
+    readonly MOUTH_NOT_PRESENT: "mouth_not_present";
+    readonly MOUTH_SCORE_TOO_HIGH: "mouth_score_too_high";
+    readonly MOUTH_SCORE_TOO_LOW: "mouth_score_too_low";
+};
+export declare const FaceCheckToInstructionCodeMap: {
+    isPresent: "face_not_present";
+    isNotPitched: "device_pitched";
+    isNotSmall: "face_too_far";
+    isNotLarge: "face_too_close";
+    isNotOutOfBounds: "face_centering";
+    isNotDim: "brightness_too_low";
+    isNotBright: "brightness_too_high";
+    isSharp: "sharpness_too_low";
+    isLeftEyePresent: "left_eye_not_present";
+    isRightEyePresent: "right_eye_not_present";
+    isMouthPresent: "mouth_not_present";
+    isMouthScoreNotTooHigh: "mouth_score_too_high";
+    isMouthScoreNotTooLow: "mouth_score_too_low";
+};
+export type FaceInstructionCode = ObjectValues<typeof FaceInstructionCodeValues>;
+export type DetectedFacePart = {
+    center: Point;
+    confidence: number;
+    size: number;
+    status: number;
+};
+export type DetectedFace = FaceImageParameters & DetectedFaceCorners & {
+    confidence: number;
+    faceSize: number;
+    leftEye: DetectedFacePart;
+    mouth: DetectedFacePart;
+    rightEye: DetectedFacePart;
+};
+export type DetectedFaceCorners = {
+    bottomRight: Point;
+    faceCenter: Point;
+    topLeft: Point;
+};
+export type FaceImageParameters = ImageParameters;

package/ui-common/src/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './events';
+export * from './document';
+export * from './face';
+export * from './common';
+export * from './magnifeye';
+export * from './smile';
+export * from './palm';
+export * from './eye-gaze';