@incodetech/welcome 1.79.0 → 1.79.1

package/dist/incode-welcome/src/IDV2/capture/Api.d.ts

@@ -29,17 +29,13 @@ type UploadIdParams = {
     ageAssurance?: boolean;
     onProgress?: (progress: number) => void;
 };
-type CaptureIdConfig = {
-    maxRetries?: number;
-};
-declare class CaptureIdError extends Error {
+export declare class CaptureIdError extends Error {
     errorKey: string;
     messageDescription?: string;
     constructor(errorKey: string, message: string, messageDescription?: string);
 }
-declare const createCaptureIdApi: (token: string, userConfig?: CaptureIdConfig) => {
+export declare const createCaptureIdApi: (token: string) => {
     uploadId(params: UploadIdParams): Promise<CaptureIdResponse>;
     reset(): void;
 };
-export { CaptureIdError, createCaptureIdApi };
 export default createCaptureIdApi;

package/dist/incode-welcome/src/IDV2/capture/CommonIssues.d.ts

@@ -1,6 +1,6 @@
-import { FC } from 'react';
-interface CommonIssuesProps {
+type CommonIssuesProps = {
     onClose: () => void;
-}
-declare const CommonIssues: FC<CommonIssuesProps>;
+    switchToManualCapture: () => void;
+};
+declare const CommonIssues: ({ onClose, switchToManualCapture, }: CommonIssuesProps) => import("react/jsx-runtime").JSX.Element;
 export default CommonIssues;

package/dist/incode-welcome/src/IDV2/capture/Counter.d.ts

@@ -0,0 +1,6 @@
+type CounterProps = {
+    children: string | number;
+    gradient?: string;
+};
+export default function Counter({ children }: CounterProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/incode-welcome/src/IDV2/capture/FrameBorder.d.ts

@@ -1,8 +1,12 @@
+import { DetectionOrientation } from '../../detection/IdDetectionManager';
+export declare const FrameContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Frame: import("styled-components").StyledComponent<"div", any, {}, never>;
 type FrameBorderProps = {
     frameColor: string;
     className?: string;
     isCapturing: boolean;
     onReadyToCapture: () => void;
+    orientation: DetectionOrientation;
 };
-declare function FrameBorder({ frameColor, className, isCapturing, onReadyToCapture, }: FrameBorderProps): import("react/jsx-runtime").JSX.Element;
+declare function FrameBorder({ frameColor, className, isCapturing, onReadyToCapture, orientation, }: FrameBorderProps): import("react/jsx-runtime").JSX.Element;
 export default FrameBorder;

package/dist/incode-welcome/src/IDV2/capture/IdProcessingStatus.d.ts

@@ -1,4 +1,5 @@
 import type { FC } from 'react';
+import { DetectionOrientation } from '../../detection/IdDetectionManager';
 import type { ErrorType } from './Api';
 type Status = 'uploading' | 'success' | 'error';
 type Props = {
@@ -8,6 +9,9 @@ type Props = {
     errorType?: ErrorType;
     onScanBack?: () => void;
     onTryAgain?: () => void;
+    mode: 'front' | 'back';
+    onContinue?: () => void;
+    orientation: DetectionOrientation;
 };
 declare const IdProcessingStatus: FC<Props>;
 export default IdProcessingStatus;

package/dist/incode-welcome/src/IDV2/capture/ManualCaptureButton.d.ts

@@ -0,0 +1,4 @@
+import type { ButtonHTMLAttributes, FC } from 'react';
+type ManualCaptureButtonProps = ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ManualCaptureButton: FC<ManualCaptureButtonProps>;
+export default ManualCaptureButton;

package/dist/incode-welcome/src/IDV2/capture/NeedHelp.d.ts

@@ -1,2 +1,5 @@
-declare const NeedHelp: () => import("react/jsx-runtime").JSX.Element;
+type NeedHelpProps = {
+    switchToManualCapture: () => void;
+};
+declare const NeedHelp: ({ switchToManualCapture }: NeedHelpProps) => import("react/jsx-runtime").JSX.Element;
 export default NeedHelp;

package/dist/incode-welcome/src/IDV2/capture/WrongSideHint.d.ts

@@ -0,0 +1,7 @@
+import type { FC } from 'react';
+export declare const FrontIdHint: FC;
+type WrongSideHintProps = {
+    side: 'front' | 'back';
+};
+declare const WrongSideHint: ({ side }: WrongSideHintProps) => import("react/jsx-runtime").JSX.Element;
+export default WrongSideHint;

package/dist/incode-welcome/src/IDV2/capture/assets/analyzing-animations/id-laser-h.json.d.ts

@@ -0,0 +1,280 @@
+declare const _default: {
+  "fr": 60,
+  "v": "5.9.6",
+  "ip": 0,
+  "op": 161,
+  "w": 390,
+  "h": 271,
+  "nm": "id_laser_h",
+  "ddd": 0,
+  "markers": [],
+  "assets": [
+    {
+      "nm": "id_laser_h",
+      "fr": 60,
+      "id": "m8gbpa7d4wklnmgw",
+      "layers": [
+        {
+          "ty": 3,
+          "ddd": 0,
+          "ind": 5,
+          "hd": false,
+          "nm": "id_laser_h - Null",
+          "sr": 1,
+          "ks": {
+            "a": { "a": 0, "k": [0, 0] },
+            "o": { "a": 0, "k": 100 },
+            "p": { "a": 0, "k": [0, 0] },
+            "r": { "a": 0, "k": 0 },
+            "s": { "a": 0, "k": [100, 100] },
+            "sk": { "a": 0, "k": 0 },
+            "sa": { "a": 0, "k": 0 }
+          },
+          "ao": 0,
+          "ip": 0,
+          "op": 162,
+          "st": 0,
+          "bm": 0
+        },
+        {
+          "ty": 3,
+          "ddd": 0,
+          "ind": 6,
+          "hd": false,
+          "nm": "Rectangle 465 - Null",
+          "sr": 1,
+          "parent": 5,
+          "ks": {
+            "a": { "a": 0, "k": [54, 133] },
+            "o": { "a": 0, "k": 100 },
+            "p": {
+              "a": 1,
+              "k": [
+                {
+                  "t": 0,
+                  "s": [75, 136],
+                  "o": { "x": [0.5], "y": [0.35] },
+                  "i": { "x": [0.15], "y": [1] },
+                  "ti": [0, 0],
+                  "to": [0, 0]
+                },
+                {
+                  "t": 59.928000000000004,
+                  "s": [315, 136],
+                  "o": { "x": [0.5], "y": [0.35] },
+                  "i": { "x": [0.15], "y": [1] },
+                  "ti": [0, 0],
+                  "to": [0, 0]
+                },
+                {
+                  "t": 69.28200000000001,
+                  "s": [315, 136],
+                  "o": { "x": [0.5], "y": [0.35] },
+                  "i": { "x": [0.15], "y": [1] },
+                  "ti": [0, 0],
+                  "to": [0, 0]
+                },
+                { "t": 141.006, "s": [75, 136] }
+              ]
+            },
+            "r": { "a": 0, "k": 0 },
+            "s": {
+              "a": 1,
+              "k": [
+                {
+                  "t": 0,
+                  "s": [100, 100],
+                  "o": { "x": [0.5], "y": [0.35] },
+                  "i": { "x": [0.15], "y": [1] }
+                },
+                {
+                  "t": 59.928000000000004,
+                  "s": [-100, 100],
+                  "o": { "x": [0.5], "y": [0.35] },
+                  "i": { "x": [0.15], "y": [1] }
+                },
+                {
+                  "t": 69.28200000000001,
+                  "s": [-100, 100],
+                  "o": { "x": [0.5], "y": [0.35] },
+                  "i": { "x": [0.15], "y": [1] }
+                },
+                { "t": 141.006, "s": [100, 100] }
+              ]
+            },
+            "sk": { "a": 0, "k": 0 },
+            "sa": { "a": 0, "k": 0 }
+          },
+          "ao": 0,
+          "ip": 0,
+          "op": 162,
+          "st": 0,
+          "bm": 0
+        },
+        {
+          "ty": 4,
+          "ddd": 0,
+          "ind": 7,
+          "hd": false,
+          "nm": "Rectangle 465",
+          "sr": 1,
+          "parent": 6,
+          "ks": {
+            "a": { "a": 0, "k": [0, 0] },
+            "p": { "a": 0, "k": [0, 0] },
+            "s": { "a": 0, "k": [100, 100] },
+            "sk": { "a": 0, "k": 0 },
+            "sa": { "a": 0, "k": 0 },
+            "r": { "a": 0, "k": 0 },
+            "o": { "a": 0, "k": 100 }
+          },
+          "ao": 0,
+          "ip": 0,
+          "op": 162,
+          "st": 0,
+          "bm": 0,
+          "shapes": [
+            {
+              "ty": "gr",
+              "nm": "Group",
+              "hd": false,
+              "np": 3,
+              "it": [
+                {
+                  "ty": "sh",
+                  "nm": "Path",
+                  "hd": false,
+                  "ks": {
+                    "a": 0,
+                    "k": {
+                      "c": true,
+                      "v": [
+                        [3.4546, 240.9087],
+                        [0.0001, 231.7465],
+                        [0.0001, 33.2534],
+                        [3.4546, 24.0912],
+                        [72.7499, 0.0474],
+                        [74.0001, 2.2451],
+                        [74.0001, 263.7549],
+                        [72.7499, 265.9526],
+                        [3.4546, 240.9087]
+                      ],
+                      "i": [
+                        [0, 0],
+                        [0, 4.4361],
+                        [0, 0],
+                        [-2.0118, 0.8997],
+                        [0, 0],
+                        [0, -1.4225],
+                        [0, 0],
+                        [0.6451, 0.2885],
+                        [0, 0]
+                      ],
+                      "o": [
+                        [-2.01182, -0.8996500000000083],
+                        [0, 0],
+                        [0, -4.436140000000002],
+                        [0, 0],
+                        [0.6451200000000057, -0.28848],
+                        [0, 0],
+                        [0, 1.4225099999999884],
+                        [0, 0],
+                        [0, 0]
+                      ]
+                    }
+                  }
+                },
+                {
+                  "ty": "gf",
+                  "o": { "a": 0, "k": 100 },
+                  "g": {
+                    "p": 4,
+                    "k": {
+                      "a": 0,
+                      "k": [
+                        0, 1, 1, 1, 0.2396, 1, 1, 1, 0.4948, 1, 1, 1, 0.8906, 1,
+                        1, 1, 0, 1, 0.2396, 0.58, 0.4948, 0.3, 0.8906, 0
+                      ]
+                    }
+                  },
+                  "s": {
+                    "a": 0,
+                    "k": [0.000003098905332132529, 132.9998798591031]
+                  },
+                  "e": { "a": 0, "k": [68.9999965407841, 132.9998798591033] },
+                  "t": 1,
+                  "nm": "Fill",
+                  "hd": false,
+                  "r": 1
+                },
+                {
+                  "ty": "tr",
+                  "a": { "a": 0, "k": [0, 0] },
+                  "p": { "a": 0, "k": [0, 0] },
+                  "s": { "a": 0, "k": [100, 100] },
+                  "sk": { "a": 0, "k": 0 },
+                  "sa": { "a": 0, "k": 0 },
+                  "r": { "a": 0, "k": 0 },
+                  "o": { "a": 0, "k": 100 }
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "layers": [
+    {
+      "ty": 3,
+      "ddd": 0,
+      "ind": 5,
+      "hd": false,
+      "nm": "id_laser_h - Null",
+      "sr": 1,
+      "ks": {
+        "a": { "a": 0, "k": [0, 0] },
+        "o": { "a": 0, "k": 100 },
+        "p": { "a": 0, "k": [0, 0] },
+        "r": { "a": 0, "k": 0 },
+        "s": { "a": 0, "k": [100, 100] },
+        "sk": { "a": 0, "k": 0 },
+        "sa": { "a": 0, "k": 0 }
+      },
+      "ao": 0,
+      "ip": 0,
+      "op": 162,
+      "st": 0,
+      "bm": 0
+    },
+    {
+      "ddd": 0,
+      "ind": 2,
+      "ty": 0,
+      "nm": "id_laser_h",
+      "refId": "m8gbpa7d4wklnmgw",
+      "sr": 1,
+      "ks": {
+        "a": { "a": 0, "k": [0, 0] },
+        "p": { "a": 0, "k": [0, 0] },
+        "s": { "a": 0, "k": [100, 100] },
+        "sk": { "a": 0, "k": 0 },
+        "sa": { "a": 0, "k": 0 },
+        "r": { "a": 0, "k": 0 },
+        "o": { "a": 0, "k": 100 }
+      },
+      "ao": 0,
+      "w": 390,
+      "h": 271,
+      "ip": 0,
+      "op": 162,
+      "st": 0,
+      "hd": false,
+      "bm": 0
+    }
+  ],
+  "meta": { "a": "", "d": "", "tc": "", "g": "Aninix" }
+}
+;
+
+export default _default;

package/dist/incode-welcome/src/IDV2/ui/Card.d.ts

@@ -1,6 +1,6 @@
-import { FC } from 'react';
+import { FC, ReactElement } from 'react';
 interface CardProps {
-    image: string;
+    image: ReactElement;
     alt?: string;
     title: string;
     body: string;

package/dist/incode-welcome/src/IDV2/ui/Container.d.ts

@@ -1,8 +1,13 @@
 import type { ReactNode } from 'react';
-export declare const StyledHeaderContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
-declare const Container: ({ children, title, subtitle, }: {
+import { SpacingValue } from './index';
+type ContainerProps = {
     children: ReactNode;
     title: string;
     subtitle?: string;
-}) => import("react/jsx-runtime").JSX.Element;
+    p?: SpacingValue;
+    px?: SpacingValue;
+    py?: SpacingValue;
+    pb?: SpacingValue;
+};
+declare const Container: ({ children, title, subtitle, p, px, py, pb, }: ContainerProps) => import("react/jsx-runtime").JSX.Element;
 export default Container;

package/dist/incode-welcome/src/IDV2/ui/H2.d.ts

@@ -0,0 +1,5 @@
+import type { HTMLAttributes } from 'react';
+import { TextProps } from '.';
+type H2Props = Omit<TextProps<'h2'>, 'as'> & HTMLAttributes<HTMLHeadingElement>;
+declare const H2: ({ children, ...props }: H2Props) => import("react/jsx-runtime").JSX.Element;
+export default H2;

package/dist/incode-welcome/src/IDV2/ui/index.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentProps, ElementType } from 'react';
 type FontSize = 'xs' | 'sm' | 'base' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl';
-type SpacingValue = 0 | 1 | 2 | 4 | 7 | 8 | 12 | 16 | 20;
+export type SpacingValue = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 12 | 16 | 20;
 type FlexDirection = 'row' | 'column' | 'row-reverse' | 'column-reverse';
 type JustifyContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
 type AlignItems = 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'stretch';
@@ -15,6 +15,7 @@ type TextOwnProps<E extends ElementType = ElementType> = {
     color?: string;
     lineHeight?: string | number;
     letterSpacing?: string | number;
+    fontFamily?: string;
 };
 export type TextProps<E extends ElementType> = TextOwnProps<E> & Omit<ComponentProps<E>, keyof TextOwnProps>;
 export declare const Text: {
@@ -28,21 +29,50 @@ export declare const Text: {
 };
 type BoxOwnProps<E extends ElementType = ElementType> = {
     as?: E;
-    m?: SpacingValue;
-    mx?: SpacingValue;
-    my?: SpacingValue;
-    mt?: SpacingValue;
-    mr?: SpacingValue;
-    mb?: SpacingValue;
-    ml?: SpacingValue;
-    p?: SpacingValue;
-    px?: SpacingValue;
-    py?: SpacingValue;
-    pt?: SpacingValue;
-    pr?: SpacingValue;
-    pb?: SpacingValue;
-    pl?: SpacingValue;
+    m?: SpacingValue | string;
+    mx?: SpacingValue | string;
+    my?: SpacingValue | string;
+    mt?: SpacingValue | string;
+    mr?: SpacingValue | string;
+    mb?: SpacingValue | string;
+    ml?: SpacingValue | string;
+    p?: SpacingValue | string;
+    px?: SpacingValue | string;
+    py?: SpacingValue | string;
+    pt?: SpacingValue | string;
+    pr?: SpacingValue | string;
+    pb?: SpacingValue | string;
+    pl?: SpacingValue | string;
     hFull?: boolean;
+    wFull?: boolean;
+    w?: SpacingValue | string;
+    h?: SpacingValue | string;
+    bg?: string;
+    borderRadius?: SpacingValue | string;
+    overflow?: 'visible' | 'hidden' | 'scroll' | 'auto' | 'clip';
+    position?: 'static' | 'relative' | 'absolute' | 'fixed' | 'sticky';
+    bottom?: string | number;
+    left?: string | number;
+    right?: string | number;
+    top?: string | number;
+    inset?: string | number;
+    boxShadow?: string;
+    zIndex?: number;
+    transition?: string;
+    transform?: string;
+    border?: string;
+    borderTop?: string;
+    borderRight?: string;
+    borderBottom?: string;
+    borderLeft?: string;
+    borderWidth?: string | number;
+    borderStyle?: 'solid' | 'dashed' | 'dotted' | 'none';
+    borderColor?: string;
+    display?: string;
+    objectFit?: 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
+    objectPosition?: string;
+    userSelect?: 'none' | 'text' | 'all';
+    WebkitUserDrag?: 'none' | 'element';
 };
 type BoxProps<E extends ElementType> = BoxOwnProps<E> & Omit<ComponentProps<E>, keyof BoxOwnProps>;
 export declare const Box: <E extends ElementType<any> = "div">(props: BoxProps<E>) => import("react/jsx-runtime").JSX.Element;
@@ -81,5 +111,21 @@ export declare const colors: {
     red: string;
     surfaceSecondary900: string;
     green: string;
+    darkGray: string;
+};
+type ImageProps = BoxProps<'img'> & {
+    objectFit?: 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
+    objectPosition?: string;
+    loading?: 'lazy' | 'eager';
+    draggable?: boolean;
+};
+export declare const Image: {
+    (props: ImageProps): import("react/jsx-runtime").JSX.Element;
+    defaultProps: {
+        objectFit: string;
+        objectPosition: string;
+        loading: string;
+        draggable: boolean;
+    };
 };
 export {};

package/dist/incode-welcome/src/addSpeech.d.ts

@@ -1,7 +1,7 @@
-import { emptyFunc } from '../../incode-utils/src';
-declare function addSpeech({ token, audio, onProgress }: {
-    token: any;
-    audio: any;
-    onProgress?: typeof emptyFunc;
-}): Promise<any>;
+type AddSpeechParams = {
+    token: string;
+    audio: string;
+    onProgress?: (progress: number) => void;
+};
+declare function addSpeech({ token, audio, onProgress }: AddSpeechParams): Promise<any>;
 export default addSpeech;

package/dist/incode-welcome/src/camera/Webcam.types.d.ts

@@ -28,6 +28,7 @@ export type WebcamProps = {
     isRecordingEnabled?: boolean;
     isKiosk?: boolean;
     flipVerticallyImage?: boolean;
+    isIdv2?: boolean;
 };
 export type UpdateCanvas = (options: {
     width?: number;

package/dist/incode-welcome/src/camera/useSelfie.d.ts

@@ -27,7 +27,7 @@ type UseSelfieProps = {
     maskCheckEnabled?: boolean;
     eyesClosedCheckEnabled?: boolean;
 };
-declare function useSelfie({ timeout, onLog, handleCapture, numberOfTries, handleNoAttempsLeft, webcam, token, isDetecting, onSwitchManualCapture, onManualCaptureSelfie, assistedOnboarding, notificationTimeout, hatCheckEnabled, lensesCheckEnabled, maskCheckEnabled, eyesClosedCheckEnabled, }: UseSelfieProps): {
+declare function useSelfie({ timeout, onLog, handleCapture, numberOfTries, handleNoAttempsLeft, webcam, token, isDetecting, onSwitchManualCapture, onManualCaptureSelfie, assistedOnboarding, notificationTimeout, hatCheckEnabled, lensesCheckEnabled, maskCheckEnabled, eyesClosedCheckEnabled, disableZoomCheck, }: UseSelfieProps): {
     notificationMessage: any;
     notificationDescription: string;
     mode: string;

package/dist/incode-welcome/src/detection/IdDetectionManager.d.ts

@@ -1,17 +1,25 @@
 import EventEmitter from 'eventemitter3';
 import { IncodeCanvas } from '../camera/IncodeCanvas';
-export type OnCapture = (canvas: IncodeCanvas, qualityElements: {
-    glare: number;
-    sharpness: number;
+import { PipelineProfile } from '../wasmUtils/pipelineProfile';
+import { IdCapture } from './detectID';
+export type OnCapture = (canvas: IncodeCanvas, options?: {
+    qualityElements?: {
+        glare: number;
+        sharpness: number;
+    };
+    isManualCapture: boolean;
 }) => void;
 export type GetCanvas = () => IncodeCanvas | undefined;
 export type DetectionState = 'detecting' | 'capturing' | 'farAway' | 'glare' | 'blur' | 'idNotDetected' | 'manualCapture';
+type BadDetectionState = 'farAway' | 'glare' | 'blur';
 export type IdSide = 'front' | 'back' | 'unknown' | '';
 export type DetectionIdType = 'FrontId' | 'BackId' | 'Passport';
+export type DetectionOrientation = 'horizontal' | 'vertical';
 export type IdDetectionSnapshot = {
     detectionState: DetectionState;
     idType: string;
     idSide: IdSide;
+    orientation: DetectionOrientation;
 };
 type IdDetectionManagerProps = {
     getCanvas: GetCanvas;
@@ -21,30 +29,36 @@ type IdDetectionManagerProps = {
 export declare class IdDetectionManager extends EventEmitter<{
     stateChange: (snapshot: IdDetectionSnapshot) => void;
 }> {
-    private pipeline;
-    private pipelineProfile;
-    private detectionState;
-    private idType;
-    private idSide;
-    private isDetecting;
-    private isProcessingLocked;
-    private detectionTimeout;
-    private getCanvas;
-    private onCapture;
-    private detectionIdType;
+    pipeline: IdCapture | null;
+    pipelineProfile: PipelineProfile | null;
+    detectionState: DetectionState;
+    idType: string;
+    idSide: IdSide;
+    orientation: DetectionOrientation;
+    isDetecting: boolean;
+    isProcessingLocked: boolean;
+    detectionTimeout: ReturnType<typeof setTimeout> | null;
+    getCanvas: GetCanvas;
+    onCapture: OnCapture;
+    detectionIdType: DetectionIdType;
     constructor({ getCanvas, onCapture, detectionIdType, }: IdDetectionManagerProps);
     startDetection(): void;
     stopDetection(): void;
-    private processFrame;
-    private initializePipeline;
-    private handleOnCapturing;
-    private handleOnCapture;
-    private setStateWithDelay;
-    private switchToManualCapture;
-    private setDetectionState;
-    private setIdType;
-    private setIdSide;
-    private emitState;
+    processFrame: () => Promise<void>;
+    initializePipeline(): Promise<void>;
+    handleOnCapturing: () => void;
+    handleOnCapture: (canvas: IncodeCanvas, qualityElements: {
+        glare: number;
+        sharpness: number;
+    }) => void;
+    setStateWithDelay(newState: BadDetectionState, timeout?: number): void;
+    switchToManualCapture: () => void;
+    setDetectionState(newState: DetectionState): void;
+    setIdType(newType: string): void;
+    setIdSide(newSide: IdSide): void;
+    setOrientation(newOrientation: DetectionOrientation): void;
+    manualCapture: () => void;
+    emitState(): void;
     getDetectionState(): DetectionState;
     getIdType(): string;
     getIdSide(): IdSide;

package/dist/incode-welcome/src/detection/detectFace.d.ts

@@ -31,7 +31,8 @@ export declare class FaceDetection {
         onTooClose: () => void;
         onCenterFace: () => void;
         onFarAway: () => void;
-        onCapturing: () => void;
+        onGetReady: () => void;
+        onGetReadyFinished: () => void;
         onBlur: () => void;
         onDark: () => void;
         onFaceAngle: () => void;

package/dist/incode-welcome/src/detection/useIdDetection.d.ts

@@ -1,4 +1,4 @@
-import { type DetectionIdType, type GetCanvas, type OnCapture } from './IdDetectionManager';
+import { type DetectionIdType, DetectionOrientation, type GetCanvas, type OnCapture } from './IdDetectionManager';
 interface UseIdDetectionProps {
     getCanvas: GetCanvas;
     onCapture: OnCapture;
@@ -19,5 +19,8 @@ declare function useIdDetection({ getCanvas, onCapture, detectionIdType, }: UseI
     isWrongSide: boolean;
     isIdle: boolean;
     isBadState: boolean;
+    orientation: DetectionOrientation;
+    switchToManualCapture: () => void;
+    onManualCapture: () => void;
 };
 export default useIdDetection;