@ahmed_hani/dot-auto-capture-ui 7.7.0 → 8.0.0

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

@@ -1,4 +1,4 @@
-import type { DeepPartial, DeepRequired } from '../../../ui-common/src/types';
+import type { DeepRequired } from '../../../ui-common/src/types';
 import type { CSSProperties } from 'styled-components';
 export type AutoCaptureTheme = {
     colors: {
@@ -29,25 +29,9 @@ export type UiAppStateInstructions = {
 export type EscalatedInstructions<I extends string> = {
     escalatedInstructions?: Partial<Record<I, string>>;
 };
-export type UiProps<I, SI = AppStateInstructions> = {
-    appStateInstructions?: SI;
-    backdropColor?: string;
-    instructions?: Partial<I>;
-    showCameraButtons?: boolean;
-    styleTarget?: HTMLElement;
-    theme?: DeepPartial<AutoCaptureTheme>;
-};
-export type BaseComponentsUiProps<P> = {
-    placeholder?: P;
-    showDetectionLayer?: boolean;
-};
 export type CameraButtonIconProps = {
     size: number;
 };
-export type HTMLElementWithProps<P> = HTMLElement & {
-    props: P;
-};
-export type CustomizationContextProps<P extends UiProps<unknown, unknown>> = Omit<P, 'appStateInstructions' | 'styleTarget' | 'theme'> & {
-    appStateInstructions: UiAppStateInstructions;
-    theme: AutoCaptureTheme;
+export type HTMLElementWithConfiguration<P> = HTMLElement & {
+    configuration: P;
 };

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

@@ -0,0 +1,60 @@
+import type { AppStateInstructions } from './common';
+import type { DeepPartial, RequireSome } from '../../../ui-common/src/types/common';
+import type { CSSProperties } from 'styled-components';
+export type AutoCaptureTheme = {
+    colors: {
+        instructionColor: string;
+        instructionColorSuccess: string;
+        instructionTextColor: string;
+        placeholderColor: string;
+        placeholderColorSuccess: string;
+    };
+    font: {
+        family: CSSProperties['fontFamily'];
+        minimumSize: number;
+        style: CSSProperties['fontStyle'];
+        weight: CSSProperties['fontWeight'];
+    };
+};
+export type ButtonControlsConfiguration = {
+    showCameraButtons?: boolean;
+};
+export type DetectionLayerControlsConfiguration = {
+    showDetectionLayer?: boolean;
+};
+export type UiControlsConfiguration = ButtonControlsConfiguration & DetectionLayerControlsConfiguration;
+type StylingConfiguration = {
+    backdropColor?: string;
+    theme?: DeepPartial<AutoCaptureTheme>;
+};
+type InstructionsConfiguration<TInstructions, TAppStateInstructions = AppStateInstructions> = {
+    appStateInstructions?: TAppStateInstructions;
+    instructions?: Partial<TInstructions>;
+};
+export type PlaceholderConfiguration<TPlaceholder> = {
+    placeholder?: TPlaceholder;
+};
+export type BaseUiConfiguration<TInstructions, TControls = ButtonControlsConfiguration, TAppStateInstructions = AppStateInstructions> = InstructionsConfiguration<TInstructions, TAppStateInstructions> & {
+    control?: TControls;
+    styleTarget?: HTMLElement;
+    styling?: StylingConfiguration;
+};
+export type InitializedButtonControlsConfiguration = Required<ButtonControlsConfiguration>;
+export type InitializedDetectionLayerControlsConfiguration = Required<DetectionLayerControlsConfiguration>;
+export type InitializedUiControlsConfiguration = InitializedButtonControlsConfiguration & InitializedDetectionLayerControlsConfiguration;
+export type InitializedUiStylingConfiguration = RequireSome<StylingConfiguration, 'backdropColor'> & {
+    theme: AutoCaptureTheme;
+};
+export type InitializedUiInstructionsConfiguration<TInstructions, TAppStateInstructions = AppStateInstructions> = {
+    appStateInstructions: TAppStateInstructions;
+    instructions: TInstructions;
+};
+export type InitializedPlaceholderConfiguration<TPlaceholder> = {
+    placeholder: TPlaceholder;
+};
+export type InitializedBaseUiConfiguration<TInstructions, TControls = InitializedButtonControlsConfiguration, TAppStateInstructions = AppStateInstructions> = InitializedUiInstructionsConfiguration<TInstructions, TAppStateInstructions> & {
+    control: TControls;
+    styleTarget?: HTMLElement;
+    styling: InitializedUiStylingConfiguration;
+};
+export {};

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

@@ -1,18 +1,19 @@
-import type { BaseComponentsUiProps, CustomizationContextProps, EscalatedInstructions, HTMLElementWithProps, UiProps } from './common';
-import type { CustomElement, DeepRequired, DocumentEscalatedInstructionCodes, DocumentInstructionCode, ObjectValues } from '../../../ui-common/src/types';
+import type { EscalatedInstructions, HTMLElementWithConfiguration } from './common';
+import type { BaseUiConfiguration, InitializedBaseUiConfiguration, InitializedPlaceholderConfiguration, InitializedUiControlsConfiguration, PlaceholderConfiguration, UiControlsConfiguration } from './configuration';
+import type { CustomElement, 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;
+                configuration: DocumentUiConfiguration;
             }>;
         }
     }
     namespace React.JSX {
         interface IntrinsicElements {
             'x-dot-document-auto-capture-ui': CustomElement<{
-                props: DocumentUiProps;
+                configuration: DocumentUiConfiguration;
             }>;
         }
     }
@@ -33,6 +34,6 @@ export declare const DocumentPlaceholderIconValues: {
 };
 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>;
+export type DocumentUiConfiguration = BaseUiConfiguration<Partial<DocumentInstructions>, UiControlsConfiguration> & PlaceholderConfiguration<DocumentPlaceholderIcon> & EscalatedInstructions<DocumentEscalatedInstructionCodes>;
+export type InitializedDocumentUiConfiguration = InitializedBaseUiConfiguration<DocumentInstructions, InitializedUiControlsConfiguration> & InitializedPlaceholderConfiguration<DocumentPlaceholderIcon> & EscalatedInstructions<DocumentEscalatedInstructionCodes>;
+export type HTMLDocumentUiElement = HTMLElementWithConfiguration<DocumentUiConfiguration>;

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

@@ -1,33 +1,34 @@
-import type { AppStateInstruction, BaseComponentsUiProps, CustomizationContextProps, HTMLElementWithProps, UiProps } from './common';
+import type { AppStateInstruction, HTMLElementWithConfiguration } from './common';
+import type { BaseUiConfiguration, ButtonControlsConfiguration, InitializedBaseUiConfiguration, InitializedButtonControlsConfiguration, InitializedPlaceholderConfiguration } from './configuration';
 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;
+                configuration: EyeGazeLivenessUiConfiguration;
             }>;
         }
     }
     namespace React.JSX {
         interface IntrinsicElements {
             'x-dot-eye-gaze-liveness-ui': CustomElement<{
-                props: EyeGazeLivenessUiProps;
+                configuration: EyeGazeLivenessUiConfiguration;
             }>;
         }
     }
 }
 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'> & {
+export type EyeGazeLivenessUiConfiguration = BaseUiConfiguration<CustomizableInstructions, ButtonControlsConfiguration, EyeGazeStateInstructions> & {
     collectionPhasePlaceholder?: string;
     corners: Array<CornerValues>;
 };
-type RequiredUiProps = DeepRequired<EyeGazeLivenessUiProps<EyeGazeInstructions>>;
-export type EyeGazeProps = CustomizationContextProps<RequiredUiProps> & {
-    collectionPhasePlaceholder: string;
+export type InitializedEyeGazeLivenessUiConfiguration = InitializedBaseUiConfiguration<EyeGazeInstructions, InitializedButtonControlsConfiguration, UiEyeGazeStateInstructions> & InitializedPlaceholderConfiguration<string> & {
+    collectionPhasePlaceholder?: string;
+    corners: Array<CornerValues>;
 };
-export type HTMLEyeGazeLivenessUiElement = HTMLElementWithProps<EyeGazeLivenessUiProps>;
+export type HTMLEyeGazeLivenessUiElement = HTMLElementWithConfiguration<EyeGazeLivenessUiConfiguration>;
 export type EyeGazeStateInstructions = {
     done?: AppStateInstruction;
     loading?: AppStateInstruction;

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

@@ -1,36 +1,25 @@
-import type { BaseComponentsUiProps, CustomizationContextProps, HTMLElementWithProps, UiProps } from './common';
-import type { CustomElement, DeepRequired, FaceInstructionCode, ObjectValues } from '../../../ui-common/src/types';
+import type { HTMLElementWithConfiguration } from './common';
+import type { BaseUiConfiguration, InitializedBaseUiConfiguration, InitializedPlaceholderConfiguration, InitializedUiControlsConfiguration, PlaceholderConfiguration, UiControlsConfiguration } from './configuration';
+import type { CustomElement, 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;
+                configuration: FaceUiConfiguration;
             }>;
         }
     }
     namespace React.JSX {
         interface IntrinsicElements {
             'x-dot-face-auto-capture-ui': CustomElement<{
-                props: FaceUiProps;
+                configuration: FaceUiConfiguration;
             }>;
         }
     }
 }
 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";
@@ -39,7 +28,6 @@ export declare const FacePlaceholderIconValues: {
 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>;
+export type FaceUiConfiguration<I = CustomizableFaceInstructions> = BaseUiConfiguration<I, UiControlsConfiguration> & PlaceholderConfiguration<FacePlaceholderIcon>;
+export type InitializedFaceUiConfiguration = InitializedBaseUiConfiguration<FaceInstructions, InitializedUiControlsConfiguration> & InitializedPlaceholderConfiguration<FacePlaceholderIcon>;
+export type HTMLFacetUiElement = HTMLElementWithConfiguration<FaceUiConfiguration>;

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

@@ -1,28 +1,28 @@
-import type { AppStateInstruction, CustomizationContextProps, HTMLElementWithProps, UiProps } from './common';
+import type { AppStateInstruction, HTMLElementWithConfiguration } from './common';
+import type { BaseUiConfiguration, ButtonControlsConfiguration, InitializedBaseUiConfiguration, InitializedButtonControlsConfiguration } from './configuration';
 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;
+                configuration: MagnifEyeLivenessUiConfiguration;
             }>;
         }
     }
     namespace React.JSX {
         interface IntrinsicElements {
             'x-dot-magnifeye-liveness-ui': CustomElement<{
-                props: MagnifEyeLivenessUiProps;
+                configuration: MagnifEyeLivenessUiConfiguration;
             }>;
         }
     }
 }
 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 MagnifEyeLivenessUiConfiguration = BaseUiConfiguration<CustomizableMagnifEyeInstructions, ButtonControlsConfiguration, MagnifEyeStateInstructions>;
+export type InitializedMagnifEyeLivenessUiConfiguration = InitializedBaseUiConfiguration<MagnifEyeInstructions, InitializedButtonControlsConfiguration, UiMagnifEyeStateInstructions>;
+export type HTMLMagnifEyeLivenessUiElement = HTMLElementWithConfiguration<MagnifEyeLivenessUiConfiguration>;
 export type MagnifEyeStateInstructions = {
     done?: AppStateInstruction;
     loading?: AppStateInstruction;

package/ui/src/types/multi-range.d.ts

@@ -1,18 +1,19 @@
-import type { BaseComponentsUiProps, CustomizationContextProps, EscalatedInstructions, HTMLElementWithProps, UiProps } from './common';
-import type { CustomElement, DeepRequired, MultiRangeEscalatedInstructionCodes, MultiRangeInstructionCode, ObjectValues } from '../../../ui-common/src/types';
+import type { EscalatedInstructions, HTMLElementWithConfiguration, UiAppStateInstructions } from './common';
+import type { BaseUiConfiguration, InitializedBaseUiConfiguration, InitializedPlaceholderConfiguration, InitializedUiControlsConfiguration, PlaceholderConfiguration, UiControlsConfiguration } from './configuration';
+import type { CustomElement, MultiRangeEscalatedInstructionCodes, MultiRangeInstructionCode, ObjectValues } from '../../../ui-common/src/types';
 export * from './common';
 declare global {
     namespace preact.JSX {
         interface IntrinsicElements {
             'x-dot-multi-range-liveness-ui': CustomElement<{
-                props: MultiRangeUiProps;
+                configuration: MultiRangeUiConfiguration;
             }>;
         }
     }
     namespace React.JSX {
         interface IntrinsicElements {
             'x-dot-multi-range-liveness-ui': CustomElement<{
-                props: MultiRangeUiProps;
+                configuration: MultiRangeUiConfiguration;
             }>;
         }
     }
@@ -22,7 +23,6 @@ export declare const MultiRangePlaceholderIconValues: {
 };
 export type MultiRangePlaceholderIcon = ObjectValues<typeof MultiRangePlaceholderIconValues>;
 export type MultiRangeInstructions = Record<MultiRangeInstructionCode, string>;
-export type MultiRangeUiProps<I = MultiRangeInstructions> = UiProps<I> & BaseComponentsUiProps<MultiRangePlaceholderIcon> & EscalatedInstructions<MultiRangeEscalatedInstructionCodes>;
-type RequiredUiProps = DeepRequired<MultiRangeUiProps<MultiRangeInstructions>>;
-export type MultiRangeProps = CustomizationContextProps<RequiredUiProps> & EscalatedInstructions<MultiRangeEscalatedInstructionCodes>;
-export type HTMLMultiRangeLivenessUiElement = HTMLElementWithProps<MultiRangeUiProps>;
+export type MultiRangeUiConfiguration = BaseUiConfiguration<MultiRangeInstructions, UiControlsConfiguration, UiAppStateInstructions> & PlaceholderConfiguration<MultiRangePlaceholderIcon> & EscalatedInstructions<MultiRangeEscalatedInstructionCodes>;
+export type InitializedMultiRangeUiConfiguration = InitializedBaseUiConfiguration<MultiRangeInstructions, InitializedUiControlsConfiguration, UiAppStateInstructions> & InitializedPlaceholderConfiguration<MultiRangePlaceholderIcon> & EscalatedInstructions<MultiRangeEscalatedInstructionCodes>;
+export type HTMLMultiRangeLivenessUiElement = HTMLElementWithConfiguration<MultiRangeUiConfiguration>;

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

@@ -1,18 +1,19 @@
-import type { BaseComponentsUiProps, CustomizationContextProps, HTMLElementWithProps, UiProps } from './common';
-import type { CustomElement, DeepRequired, ObjectValues, PalmInstructionCode } from '../../../ui-common/src/types';
+import type { HTMLElementWithConfiguration } from './common';
+import type { BaseUiConfiguration, InitializedBaseUiConfiguration, InitializedPlaceholderConfiguration, InitializedUiControlsConfiguration, PlaceholderConfiguration, UiControlsConfiguration } from './configuration';
+import type { CustomElement, 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;
+                configuration: PalmUiConfiguration;
             }>;
         }
     }
     namespace React.JSX {
         interface IntrinsicElements {
             'x-dot-palm-capture-ui': CustomElement<{
-                props: PalmUiProps;
+                configuration: PalmUiConfiguration;
             }>;
         }
     }
@@ -23,6 +24,6 @@ export declare const PalmPlaceholderIconValues: {
 };
 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>;
+export type PalmUiConfiguration = BaseUiConfiguration<Partial<PalmInstructions>, UiControlsConfiguration> & PlaceholderConfiguration<PalmPlaceholderIcon>;
+export type InitializedPalmUiConfiguration = InitializedBaseUiConfiguration<PalmInstructions, InitializedUiControlsConfiguration> & InitializedPlaceholderConfiguration<PalmPlaceholderIcon>;
+export type HTMLPalmUiElement = HTMLElementWithConfiguration<PalmUiConfiguration>;

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

@@ -1,32 +1,25 @@
-import type { AppStateInstruction, CustomizationContextProps, EscalatedInstructions, HTMLElementWithProps, UiProps } from './common';
-import type { CustomElement, DeepRequired, SmileEscalatedInstructionCodes, SmileInstructionCode } from '../../../ui-common/src/types';
+import type { EscalatedInstructions, HTMLElementWithConfiguration, UiAppStateInstructions } from './common';
+import type { BaseUiConfiguration, ButtonControlsConfiguration, InitializedBaseUiConfiguration, InitializedButtonControlsConfiguration, InitializedPlaceholderConfiguration, PlaceholderConfiguration } from './configuration';
+import type { CustomElement, 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;
+                configuration: SmileLivenessUiConfiguration;
             }>;
         }
     }
     namespace React.JSX {
         interface IntrinsicElements {
             'x-dot-smile-liveness-ui': CustomElement<{
-                props: SmileLivenessUiProps;
+                configuration: SmileLivenessUiConfiguration;
             }>;
         }
     }
 }
 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>;
-};
+export type SmileLivenessUiConfiguration = BaseUiConfiguration<CustomizableSmileInstructions, ButtonControlsConfiguration, UiAppStateInstructions> & PlaceholderConfiguration<string> & EscalatedInstructions<SmileEscalatedInstructionCodes>;
+export type InitializedSmileLivenessUiConfiguration = InitializedBaseUiConfiguration<SmileInstructions, InitializedButtonControlsConfiguration, UiAppStateInstructions> & InitializedPlaceholderConfiguration<string> & EscalatedInstructions<SmileEscalatedInstructionCodes>;
+export type HTMLSmileLivenessUiElement = HTMLElementWithConfiguration<SmileLivenessUiConfiguration>;

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

@@ -16,28 +16,6 @@ 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<TDetectedObject> = {
-    assetsDirectoryPath?: string;
-    cameraFacing?: FacingModeValues;
-    candidateSelectionDurationMillis?: number;
-    captureMode?: CaptureModeValues;
-    isVideoCaptureEnabled?: boolean;
-    onError: (e: Error) => void;
-    onPhotoTaken: (imageData: CallbackImage<TDetectedObject>, content: Uint8Array) => void;
-    sessionToken?: string;
-    styleTarget?: HTMLElement;
-    transactionCountingToken?: string;
-};
 export type ImageParameters = {
     brightness: number;
     sharpness: number;
@@ -54,21 +32,22 @@ export type Point = {
     y: number;
 };
 export declare const AppStateValues: {
-    readonly LOADING: "LOADING";
-    readonly ERROR: "ERROR";
-    readonly WAITING: "WAITING";
-    readonly RUNNING: "RUNNING";
-    readonly COMPLETE: "COMPLETE";
+    readonly LOADING: "loading";
+    readonly ERROR: "error";
+    readonly WAITING: "waiting";
+    readonly RUNNING: "running";
+    readonly COMPLETE: "complete";
 };
 export declare const LivenessStateValues: {
-    readonly DONE: "DONE";
-    readonly LOADING: "LOADING";
-    readonly ERROR: "ERROR";
-    readonly WAITING: "WAITING";
-    readonly RUNNING: "RUNNING";
-    readonly COMPLETE: "COMPLETE";
+    readonly DONE: "done";
+    readonly LOADING: "loading";
+    readonly ERROR: "error";
+    readonly WAITING: "waiting";
+    readonly RUNNING: "running";
+    readonly COMPLETE: "complete";
 };
 export type AppState = ObjectValues<typeof AppStateValues>;
+export type LivenessAppState = ObjectValues<typeof LivenessStateValues>;
 export type Crop = {
     height: number;
     shiftX: number;
@@ -89,9 +68,15 @@ export type DetectedCorners = {
     topLeft: Point;
     topRight: Point;
 };
-export type ThresholdInterval = {
-    max: number;
-    min: number;
+export type MinOrMaxInterval = {
+    max?: number;
+    min?: number;
+};
+export type MinInterval = {
+    min?: number;
+};
+export type MaxInterval = {
+    max?: number;
 };
 export declare const EyeInstructionCodeValues: {
     readonly EYE_NOT_PRESENT: "eye_not_present";

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

@@ -1,4 +1,4 @@
-import type { DetectedCorners, ImageParameters, ObjectValues } from './common';
+import type { ObjectValues } from './common';
 export declare const DocumentInstructionCodeValues: {
     readonly CANDIDATE_SELECTION: "candidate_selection";
     readonly DOCUMENT_CENTERING: "document_centering";
@@ -19,12 +19,4 @@ export declare const DocumentCheckToInstructionCodeMap: {
     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-deprecated.d.ts

@@ -0,0 +1,20 @@
+import type { DocumentCustomEvent } from './document';
+import type { FaceCustomEvent } from './face';
+import type { PalmCustomEvent } from './palm';
+import type { DocumentInstructionCode } from '../document';
+import type { FaceInstructionCode } from '../face';
+import type { PalmInstructionCode } from '../palm';
+/**
+ * @deprecated InstructionChangeEventCodeMap should be not used in new architecture (will be removed in 9.0.0 major version)
+ * Each component should have its own event dispatcher class with proper type definitions
+ */
+export type InstructionChangeEventCodeMap = {
+    [DocumentCustomEvent.INSTRUCTION_CHANGED]: DocumentInstructionCode;
+    [FaceCustomEvent.INSTRUCTION_CHANGED]: FaceInstructionCode;
+    [PalmCustomEvent.INSTRUCTION_CHANGED]: PalmInstructionCode;
+};
+/**
+ * @deprecated CaptureCustomEvent should be not used in new architecture (will be removed in 9.0.0 major version)
+ * use-camera-control-events and use-capture will be removed by migration to new architecture
+ */
+export type CaptureCustomEvent = typeof PalmCustomEvent | typeof DocumentCustomEvent | typeof FaceCustomEvent;

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

@@ -1,11 +1,5 @@
-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";
@@ -54,12 +48,6 @@ export type InstructionEscalatedEvent<T> = {
         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;
@@ -99,7 +87,6 @@ export type DetectionChangedEvent<TDetectedObject, TInstructionCode> = {
 } & Event;
 export type CommonCustomEventKeys = {
     CAMERA_PROPS_CHANGED: string;
-    CHALLENGE_VALUE_CHANGED: string;
     CONTROL: string;
     DETECTION_CHANGED: string;
     INSTRUCTION_CHANGED: string;

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

@@ -1,10 +1,10 @@
 import type { InstructionChangeEvent, InstructionEscalatedEvent } from './common';
-import type { DetectedDocument, DocumentInstructionCode } from '../document';
+import type { DocumentInstructionCode } from '../document';
+import type { DetectedDocument } from '../modality/detection/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",
+    DETECTION_CHANGED = "document-auto-capture:detection-changed",
     INSTRUCTION_CHANGED = "document-auto-capture:instruction-changed",
     INSTRUCTION_ESCALATED = "document-auto-capture:instruction-escalated",
     STATE_CHANGED = "document-auto-capture:state-changed",
@@ -16,8 +16,4 @@ export type DetectedDocumentChangeEvent = {
     };
 } & 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/face.d.ts

@@ -1,14 +1,21 @@
 import type { InstructionChangeEvent } from './common';
-import type { DetectedFace, FaceInstructionCode } from '../face';
+import type { FaceInstructionCode } from '../face';
+import type { DetectedFace } from '../modality/detection/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",
+    DETECTION_CHANGED = "face-auto-capture:detection-changed",
+    /**
+     * @deprecated Use DETECTION_CHANGED instead (will be removed in 9.0.0 major version)
+     */
     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"
 }
+/**
+ * @deprecated Use OnDetectionCallbackParams instead (will be removed in 9.0.0 major version)
+ */
 export type DetectedFaceChangeEvent = {
     detail?: {
         detectedObject: DetectedFace;

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

@@ -7,3 +7,4 @@ export * from './smile';
 export * from './palm';
 export * from './eye-gaze';
 export * from './multi-range';
+export * from './common-deprecated';

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

@@ -1,9 +1,10 @@
 import type { InstructionChangeEvent } from './common';
-import type { DetectedPalm, PalmInstructionCode } from '../palm';
+import type { DetectedPalm } from '../modality/detection/palm';
+import type { 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",
+    DETECTION_CHANGED = "palm-capture:detection-changed",
     INSTRUCTION_CHANGED = "palm-capture:instruction-changed",
     STATE_CHANGED = "palm-capture:state-changed",
     VIDEO_ELEMENT_SIZE = "palm-capture:video-element-size"

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

@@ -1,8 +1,13 @@
 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 declare const SmileCustomEvent: {
+    readonly DETECTION_CHANGED: "smile-auto-capture:detection-changed";
+    readonly CAMERA_PROPS_CHANGED: "smile-auto-capture:camera-props-changed";
+    readonly CONTROL: "smile-auto-capture:control";
+    readonly INSTRUCTION_CHANGED: "smile-auto-capture:instruction-changed";
+    readonly INSTRUCTION_ESCALATED: "smile-auto-capture:instruction-escalated";
+    readonly VIDEO_ELEMENT_SIZE: "smile-auto-capture:video-element-size";
+    readonly STATE_CHANGED: "smile-auto-capture:state-changed";
+    readonly PHASE_CHANGED: "smile-auto-capture:phase-changed";
+};
 export type SmileInstructionEscalatedEvent = InstructionEscalatedEvent<SmileInstructionCode>;