@aws-amplify/ui-react-liveness 3.3.9 → 3.4.1

package/dist/styles.css

@@ -4250,11 +4250,26 @@ html[dir=rtl] .amplify-field-group__inner-start {
   z-index: 1;
 }
 
-.amplify-liveness-loader {
+.amplify-liveness-loader .amplify-liveness-centered-loader {
+  transform: translate(-50%, -50%);
+}
+
+.amplify-liveness-centered-loader {
   position: absolute;
   left: 50%;
   top: 50%;
-  transform: translate(-50%, -50%);
+}
+
+.amplify-liveness-connecting-loader {
+  display: flex;
+  position: absolute;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  z-index: 3;
+  width: 100%;
+  height: 100%;
+  background-color: var(--amplify-colors-background-primary);
 }
 
 .amplify-liveness-oval-canvas {

package/dist/types/components/FaceLivenessDetector/LivenessCheck/CameraSelector.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface CameraSelectorProps {
+    deviceId?: string;
+    onSelect: (e: React.ChangeEvent<HTMLSelectElement>) => void;
+    devices: MediaDeviceInfo[];
+}
+export declare const CameraSelector: (props: CameraSelectorProps) => JSX.Element;
+export {};

package/dist/types/components/FaceLivenessDetector/LivenessCheck/LivenessCameraModule.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { FaceMatchState } from '../service';
 import type { InstructionDisplayText, ErrorDisplayText, HintDisplayText, StreamDisplayText, CameraDisplayText } from '../displayText';
 import type { FaceLivenessDetectorComponents } from '../shared/DefaultStartScreenComponents';
+export declare const selectChallengeType: import("../hooks").LivenessSelectorFn<string | undefined>;
 export declare const selectVideoConstraints: import("../hooks").LivenessSelectorFn<MediaTrackConstraints | undefined>;
 export declare const selectVideoStream: import("../hooks").LivenessSelectorFn<MediaStream | undefined>;
 export declare const selectFaceMatchPercentage: import("../hooks").LivenessSelectorFn<number | undefined>;

package/dist/types/components/FaceLivenessDetector/index.d.ts

@@ -3,3 +3,4 @@ export { default as FaceLivenessDetector } from './FaceLivenessDetector';
 export type { FaceLivenessDetectorCoreProps } from './FaceLivenessDetectorCore';
 export { default as FaceLivenessDetectorCore } from './FaceLivenessDetectorCore';
 export type { AwsCredentialProvider, AwsTemporaryCredentials, AwsCredentials, ErrorState, } from './service';
+export { FACE_MOVEMENT_CHALLENGE, FACE_MOVEMENT_AND_LIGHT_CHALLENGE, SUPPORTED_CHALLENGES, } from './service';

package/dist/types/components/FaceLivenessDetector/service/types/machine.d.ts

@@ -1,9 +1,21 @@
 import type { ActorRef, Interpreter, State } from 'xstate';
-import type { ValidationException, InternalServerException, ThrottlingException, ServiceQuotaExceededException, SessionInformation } from '@aws-sdk/client-rekognitionstreaming';
-import type { FaceLivenessDetectorCoreProps, FaceMatchState, LivenessOvalDetails, IlluminationState } from './liveness';
+import type { FaceMovementServerChallenge, FaceMovementAndLightServerChallenge, InternalServerException, ServiceQuotaExceededException, SessionInformation, ValidationException, ThrottlingException } from '@aws-sdk/client-rekognitionstreaming';
+import type { FACE_MOVEMENT_CHALLENGE, FACE_MOVEMENT_AND_LIGHT_CHALLENGE, StreamRecorder, ColorSequenceDisplay } from '../utils';
 import type { ErrorState } from './error';
-import type { VideoRecorder, LivenessStreamProvider, FreshnessColorDisplay } from '../utils';
 import type { Face, FaceDetection } from './faceDetection';
+import type { FaceLivenessDetectorCoreProps, FaceMatchState, LivenessOvalDetails, IlluminationState } from './liveness';
+interface Challenge {
+    Name: string;
+}
+export interface FaceMovementAndLightChallenge extends Challenge, FaceMovementAndLightServerChallenge {
+    Name: (typeof FACE_MOVEMENT_AND_LIGHT_CHALLENGE)['type'];
+}
+export interface FaceMovementChallenge extends Challenge, FaceMovementServerChallenge {
+    Name: (typeof FACE_MOVEMENT_CHALLENGE)['type'];
+}
+export interface ParsedSessionInformation {
+    Challenge: FaceMovementChallenge | FaceMovementAndLightChallenge | undefined;
+}
 export interface FaceMatchAssociatedParams {
     illuminationState?: IlluminationState;
     faceMatchState?: FaceMatchState;
@@ -16,7 +28,6 @@ export interface FreshnessColorAssociatedParams {
     freshnessColorEl?: HTMLCanvasElement;
     freshnessColors?: string[];
     freshnessColorsComplete?: boolean;
-    freshnessColorDisplay?: FreshnessColorDisplay;
 }
 export interface OvalAssociatedParams {
     faceDetector?: FaceDetection;
@@ -29,30 +40,31 @@ export interface VideoAssociatedParams {
     videoEl?: HTMLVideoElement;
     canvasEl?: HTMLCanvasElement;
     videoMediaStream?: MediaStream;
-    videoRecorder?: VideoRecorder;
-    recordingStartTimestampMs?: number;
+    recordingStartTimestamp?: number;
     isMobile?: boolean;
     selectedDeviceId?: string;
     selectableDevices?: MediaDeviceInfo[];
 }
 export interface LivenessContext {
-    challengeId?: string;
-    componentProps?: FaceLivenessDetectorCoreProps;
-    errorState?: ErrorState;
-    errorMessage?: string;
-    faceMatchAssociatedParams?: FaceMatchAssociatedParams;
-    faceMatchStateBeforeStart?: FaceMatchState;
-    failedAttempts?: number;
-    freshnessColorAssociatedParams?: FreshnessColorAssociatedParams;
-    isFaceFarEnoughBeforeRecording?: boolean;
-    isRecordingStopped?: boolean;
-    livenessStreamProvider?: LivenessStreamProvider;
-    maxFailedAttempts?: number;
-    ovalAssociatedParams?: OvalAssociatedParams;
-    responseStreamActorRef?: ActorRef<any>;
-    serverSessionInformation?: SessionInformation;
-    shouldDisconnect?: boolean;
-    videoAssociatedParams?: VideoAssociatedParams;
+    challengeId: string | undefined;
+    colorSequenceDisplay: ColorSequenceDisplay | undefined;
+    componentProps: FaceLivenessDetectorCoreProps | undefined;
+    errorMessage: string | undefined;
+    errorState: ErrorState | undefined;
+    faceMatchAssociatedParams: FaceMatchAssociatedParams | undefined;
+    faceMatchStateBeforeStart: FaceMatchState | undefined;
+    failedAttempts: number | undefined;
+    freshnessColorAssociatedParams: FreshnessColorAssociatedParams | undefined;
+    isFaceFarEnoughBeforeRecording: boolean | undefined;
+    isRecordingStopped: boolean | undefined;
+    livenessStreamProvider: StreamRecorder | undefined;
+    maxFailedAttempts: number | undefined;
+    ovalAssociatedParams: OvalAssociatedParams | undefined;
+    parsedSessionInformation: ParsedSessionInformation | undefined;
+    responseStreamActorRef: ActorRef<any> | undefined;
+    serverSessionInformation: SessionInformation | undefined;
+    shouldDisconnect: boolean | undefined;
+    videoAssociatedParams: VideoAssociatedParams | undefined;
 }
 export type LivenessEventTypes = 'BEGIN' | 'CONNECTION_TIMEOUT' | 'START_RECORDING' | 'TIMEOUT' | 'ERROR' | 'CANCEL' | 'SET_SESSION_INFO' | 'DISCONNECT_EVENT' | 'SET_DOM_AND_CAMERA_DETAILS' | 'UPDATE_DEVICE_AND_STREAM' | 'SERVER_ERROR' | 'RUNTIME_ERROR' | 'RETRY_CAMERA_CHECK' | 'MOBILE_LANDSCAPE_WARNING';
 export type LivenessEventData = Record<PropertyKey, any>;
@@ -99,7 +111,8 @@ export interface StreamActorCallback {
     (params: {
         type: 'SET_SESSION_INFO';
         data: {
-            sessionInfo: SessionInformation | undefined;
+            serverSessionInformation: SessionInformation | undefined;
         };
     }): void;
 }
+export {};

package/dist/types/components/FaceLivenessDetector/service/utils/ColorSequenceDisplay/ColorSequenceDisplay.d.ts

@@ -0,0 +1,55 @@
+interface SequenceColors {
+    sequenceColor: SequenceColorValue;
+    prevSequenceColor: SequenceColorValue;
+}
+export interface SequenceChangeParams extends SequenceColors {
+    sequenceIndex: number;
+    sequenceStartTime: number;
+}
+export interface SequenceColorChangeParams extends SequenceColors {
+    heightFraction: number;
+}
+export type SequenceColorValue = `rgb(${string},${string},${string})`;
+export interface ColorSequence {
+    color: SequenceColorValue;
+    downscrollDuration: number;
+    flatDisplayDuration: number;
+}
+type OnSequenceChange = (params: SequenceChangeParams) => void;
+export interface StartSequencesParams {
+    /**
+     * called on sequence change
+     */
+    onSequenceChange?: OnSequenceChange;
+    /**
+     * called on sequence color change
+     */
+    onSequenceColorChange?: (params: SequenceColorChangeParams) => void;
+    /**
+     * called on sequence start
+     */
+    onSequenceStart?: () => void;
+    /**
+     * called on all sequences complete
+     */
+    onSequencesComplete?: () => void;
+}
+export type ColorSequences = ColorSequence[];
+export declare class ColorSequenceDisplay {
+    #private;
+    /**
+     * Iterates over provided color sequences and executes sequence event callbacks
+     *
+     * @param {ColorSequences} colorSequences array of color sequences to iterate over
+     */
+    constructor(colorSequences: ColorSequences);
+    /**
+     * Start sequence iteration and execute event callbacks
+     *
+     * @async
+     * @param {StartSequencesParams} params Sequence event handlers
+     * @returns {Promise<boolean>} Resolves to true when complete
+     */
+    startSequences(params?: StartSequencesParams): Promise<boolean>;
+}
+export {};

package/dist/types/components/FaceLivenessDetector/service/utils/ColorSequenceDisplay/index.d.ts

@@ -0,0 +1,2 @@
+export type { ColorSequence, SequenceChangeParams, SequenceColorValue, } from './ColorSequenceDisplay';
+export { ColorSequenceDisplay } from './ColorSequenceDisplay';

package/dist/types/components/FaceLivenessDetector/service/utils/StreamRecorder/StreamRecorder.d.ts

@@ -0,0 +1,15 @@
+import type { VideoStream, StreamResult, StreamResultType } from '../types';
+export declare class StreamRecorder {
+    #private;
+    constructor(stream: MediaStream);
+    getVideoStream(): VideoStream;
+    setNewVideoStream(stream: MediaStream): void;
+    dispatchStreamEvent<T extends StreamResultType>(event: T extends 'streamStop' ? Pick<StreamResult<T>, 'type'> : StreamResult<T>): void;
+    getRecordingStartTimestamp(): number;
+    getRecordingEndedTimestamp(): number;
+    startRecording(): void;
+    isRecording(): boolean;
+    getChunksLength(): number;
+    hasRecordingStarted(): boolean;
+    stopRecording(): Promise<void>;
+}

package/dist/types/components/FaceLivenessDetector/service/utils/StreamRecorder/index.d.ts

@@ -0,0 +1 @@
+export { StreamRecorder } from './StreamRecorder';

package/dist/types/components/FaceLivenessDetector/service/utils/TelemetryReporter/TelemetryReporter.d.ts

@@ -0,0 +1,8 @@
+import type { StartFaceLivenessSessionCommandInput, StartFaceLivenessSessionCommandOutput } from '@aws-sdk/client-rekognitionstreaming';
+import type { BuildHandler, BuildHandlerArguments, BuildHandlerOutput } from '@smithy/types';
+export declare class TelemetryReporter {
+    static attemptCount: number;
+    static timestamp: number;
+    static getAttemptCountAndUpdateTimestamp(): number;
+}
+export declare const createTelemetryReporterMiddleware: (attemptCount: number, preCheckViewEnabled: boolean) => (next: BuildHandler<StartFaceLivenessSessionCommandInput, StartFaceLivenessSessionCommandOutput>) => (args: BuildHandlerArguments<StartFaceLivenessSessionCommandInput>) => Promise<BuildHandlerOutput<StartFaceLivenessSessionCommandOutput>>;

package/dist/types/components/FaceLivenessDetector/service/utils/TelemetryReporter/index.d.ts

@@ -0,0 +1,2 @@
+import { TelemetryReporter, createTelemetryReporterMiddleware } from './TelemetryReporter';
+export { createTelemetryReporterMiddleware, TelemetryReporter };

package/dist/types/components/FaceLivenessDetector/service/utils/constants.d.ts

@@ -1,12 +1,10 @@
-export declare const FACE_DISTANCE_THRESHOLD = 0.32;
-export declare const REDUCED_THRESHOLD = 0.4;
-export declare const REDUCED_THRESHOLD_MOBILE = 0.37;
 export declare const PUPIL_DISTANCE_WEIGHT = 2;
 export declare const FACE_HEIGHT_WEIGHT = 1.8;
 export declare const FACE_MATCH_RANGE_MIN = 0;
 export declare const FACE_MATCH_RANGE_MAX = 1;
 export declare const FACE_MATCH_WEIGHT_MIN = 0.25;
 export declare const FACE_MATCH_WEIGHT_MAX = 0.75;
+export declare const OVAL_HEIGHT_WIDTH_RATIO = 1.618;
 export declare const WS_CLOSURE_CODE: {
     SUCCESS_CODE: number;
     DEFAULT_ERROR_CODE: number;
@@ -15,3 +13,29 @@ export declare const WS_CLOSURE_CODE: {
     RUNTIME_ERROR: number;
     USER_ERROR_DURING_CONNECTION: number;
 };
+export declare const TIME_SLICE = 1000;
+export declare const TICK_RATE = 10;
+/**
+ * The number of seconds before the presigned URL expires.
+ * Used to override aws sdk default value of 60
+ */
+export declare const REQUEST_EXPIRY = 299;
+/**
+ * The maximum time in milliseconds that the connection phase of a request
+ * may take before the connection attempt is abandoned.
+ */
+export declare const CONNECTION_TIMEOUT = 10000;
+/**
+ * Indicates connection success
+ */
+export declare const SUCCESS_STATUS_CODE = 200;
+interface ChallengeType {
+    type: string;
+    version: string;
+}
+export declare const FACE_MOVEMENT_AND_LIGHT_CHALLENGE: ChallengeType;
+export declare const FACE_MOVEMENT_CHALLENGE: ChallengeType;
+export declare const SUPPORTED_CHALLENGES: ChallengeType[];
+export declare const queryParameterString: string;
+export declare const DEFAULT_WS_CONNECTION_TIMEOUT_MS = 2000;
+export {};

package/dist/types/components/FaceLivenessDetector/service/utils/createRequestStreamGenerator/createRequestStreamGenerator.d.ts

@@ -0,0 +1,15 @@
+import type { LivenessRequestStream } from '@aws-sdk/client-rekognitionstreaming';
+import type { VideoStream } from '../types';
+interface RequestStream extends AsyncGenerator<LivenessRequestStream> {
+}
+type GetRequestStream = () => RequestStream;
+/**
+ * Creates an async generator that reads over the provided stream and yielding stream results
+ *
+ * @param {VideoStream} stream target video stream
+ * @returns {GetRequestStream} async request stream generator
+ */
+export declare function createRequestStreamGenerator(stream: VideoStream): {
+    getRequestStream: GetRequestStream;
+};
+export {};

package/dist/types/components/FaceLivenessDetector/service/utils/createRequestStreamGenerator/index.d.ts

@@ -0,0 +1,2 @@
+export { createRequestStreamGenerator } from './createRequestStreamGenerator';
+export { createSessionStartEvent, createSessionEndEvent, createColorDisplayEvent, getTrackDimensions, } from './utils';

package/dist/types/components/FaceLivenessDetector/service/utils/createRequestStreamGenerator/utils.d.ts

@@ -0,0 +1,30 @@
+import type { ClientSessionInformationEvent, VideoEvent } from '@aws-sdk/client-rekognitionstreaming';
+import type { LivenessContext, ParsedSessionInformation } from '../../types';
+import type { SequenceChangeParams } from '../ColorSequenceDisplay';
+import type { StreamResult } from '../types';
+interface TrackDimensions {
+    trackHeight: number;
+    trackWidth: number;
+}
+export declare const createVideoEvent: (result: Exclude<StreamResult, StreamResult<'sessionInfo'>>) => Promise<VideoEvent>;
+export declare const getTrackDimensions: (stream: MediaStream) => TrackDimensions;
+interface CreateSessionEndEventParams extends TrackDimensions {
+    parsedSessionInformation: ParsedSessionInformation;
+    challengeId: NonNullable<LivenessContext['challengeId']>;
+    faceMatchAssociatedParams: NonNullable<LivenessContext['faceMatchAssociatedParams']>;
+    ovalAssociatedParams: NonNullable<LivenessContext['ovalAssociatedParams']>;
+    recordingEndedTimestamp: number;
+}
+export declare function createSessionEndEvent({ parsedSessionInformation, challengeId, faceMatchAssociatedParams, ovalAssociatedParams, recordingEndedTimestamp, trackHeight, trackWidth, }: CreateSessionEndEventParams): ClientSessionInformationEvent;
+interface CreateSessionStartEventParams extends TrackDimensions {
+    parsedSessionInformation: ParsedSessionInformation;
+    challengeId: NonNullable<LivenessContext['challengeId']>;
+    ovalAssociatedParams: NonNullable<LivenessContext['ovalAssociatedParams']>;
+    recordingStartedTimestamp: number;
+}
+export declare function createSessionStartEvent({ parsedSessionInformation, challengeId, ovalAssociatedParams, recordingStartedTimestamp, trackHeight, trackWidth, }: CreateSessionStartEventParams): ClientSessionInformationEvent;
+interface CreateColorDisplayEventParams extends SequenceChangeParams {
+    challengeId: string;
+}
+export declare function createColorDisplayEvent({ challengeId, sequenceStartTime, sequenceIndex, sequenceColor, prevSequenceColor, }: CreateColorDisplayEventParams): ClientSessionInformationEvent;
+export {};

package/dist/types/components/FaceLivenessDetector/service/utils/createStreamingClient/Signer.d.ts

@@ -1,6 +1,5 @@
 import { SignatureV4 } from '@smithy/signature-v4';
 import type { HttpRequest as HttpRequest, RequestPresigningArguments } from './types';
-export declare const REQUEST_EXPIRY = 299;
 export declare class Signer extends SignatureV4 {
     presign(request: HttpRequest, options?: Omit<RequestPresigningArguments, 'expiresIn'>): Promise<HttpRequest>;
 }

package/dist/types/components/FaceLivenessDetector/service/utils/createStreamingClient/createStreamingClient.d.ts

@@ -1,10 +1,32 @@
-import { RekognitionStreamingClient } from '@aws-sdk/client-rekognitionstreaming';
+import type { LivenessRequestStream, LivenessResponseStream, StartFaceLivenessSessionCommandInput } from '@aws-sdk/client-rekognitionstreaming';
 import type { AwsCredentialProvider } from '../../types';
-interface CreateClientConfig {
-    credentialsProvider?: AwsCredentialProvider;
-    endpointOverride?: string;
+export interface RequestStream extends AsyncGenerator<LivenessRequestStream> {
+}
+export interface ResponseStream extends AsyncIterable<LivenessResponseStream> {
+}
+export interface CreateClientConfig {
+    credentialsProvider: AwsCredentialProvider | undefined;
+    endpointOverride: string | undefined;
     region: string;
+    attemptCount: number;
+    preCheckViewEnabled: boolean;
     systemClockOffset?: number;
 }
-export declare function createStreamingClient({ credentialsProvider, endpointOverride, region, systemClockOffset, }: CreateClientConfig): Promise<RekognitionStreamingClient>;
+interface GetResponseStreamInput {
+    requestStream: RequestStream;
+    sessionId: StartFaceLivenessSessionCommandInput['SessionId'];
+    videoHeight: StartFaceLivenessSessionCommandInput['VideoHeight'];
+    videoWidth: StartFaceLivenessSessionCommandInput['VideoWidth'];
+}
+type GetReponseStream = (input: GetResponseStreamInput) => Promise<ResponseStream>;
+/**
+ * Initializes an instance of the Rekognition streaming client, returns `getResponseStream`
+ *
+ * @async
+ * @param clientConfig configuration fpr the client
+ * @returns {Promise<{ getResponseStream: GetReponseStream }>}
+ */
+export declare function createStreamingClient(clientConfig: CreateClientConfig): Promise<{
+    getResponseStream: GetReponseStream;
+}>;
 export {};

package/dist/types/components/FaceLivenessDetector/service/utils/createStreamingClient/index.d.ts

@@ -1 +1,2 @@
+export type { ResponseStream } from './createStreamingClient';
 export { createStreamingClient } from './createStreamingClient';

package/dist/types/components/FaceLivenessDetector/service/utils/getFaceMatchStateInLivenessOval.d.ts

@@ -1,17 +1,16 @@
-import type { LivenessOvalDetails, Face } from '../types';
+import type { Face, LivenessOvalDetails, ParsedSessionInformation } from '../types';
 import { FaceMatchState } from '../types';
-import type { SessionInformation } from '@aws-sdk/client-rekognitionstreaming';
 interface MatchStateInOvalParams {
     face: Face;
     ovalDetails: LivenessOvalDetails;
     initialFaceIntersection: number;
-    sessionInformation: SessionInformation;
+    parsedSessionInformation: ParsedSessionInformation;
     frameHeight: number;
 }
 /**
  * Returns the state of the provided face with respect to the provided liveness oval.
  */
-export declare function getFaceMatchStateInLivenessOval({ face, ovalDetails, initialFaceIntersection, sessionInformation, frameHeight, }: MatchStateInOvalParams): {
+export declare function getFaceMatchStateInLivenessOval({ face, ovalDetails, initialFaceIntersection, parsedSessionInformation, frameHeight, }: MatchStateInOvalParams): {
     faceMatchState: FaceMatchState;
     faceMatchPercentage: number;
 };

package/dist/types/components/FaceLivenessDetector/service/utils/index.d.ts

@@ -1,7 +1,10 @@
 export * from './blazefaceFaceDetection';
-export * from './videoRecorder';
+export * from './getFaceMatchStateInLivenessOval';
 export * from './support';
 export * from './liveness';
-export * from './getFaceMatchStateInLivenessOval';
-export * from './streamProvider';
-export * from './freshnessColorDisplay';
+export { ColorSequenceDisplay } from './ColorSequenceDisplay';
+export { FACE_MOVEMENT_CHALLENGE, FACE_MOVEMENT_AND_LIGHT_CHALLENGE, SUPPORTED_CHALLENGES, } from './constants';
+export { createRequestStreamGenerator, createSessionStartEvent, createSessionEndEvent, createColorDisplayEvent, getTrackDimensions, } from './createRequestStreamGenerator';
+export { createStreamingClient } from './createStreamingClient';
+export { isFaceMovementAndLightChallenge, isFaceMovementChallenge, createSessionInfoFromServerSessionInformation, } from './sessionInformation';
+export { StreamRecorder } from './StreamRecorder';

package/dist/types/components/FaceLivenessDetector/service/utils/liveness.d.ts

@@ -1,8 +1,6 @@
-import type { LivenessOvalDetails, Face, BoundingBox, ErrorState } from '../types';
+import type { LivenessOvalDetails, Face, BoundingBox, ErrorState, ParsedSessionInformation, FaceDetection } from '../types';
 import { IlluminationState, FaceMatchState } from '../types';
-import type { FaceDetection } from '../types/faceDetection';
-import type { ClientFreshnessColorSequence } from '../types/service';
-import type { SessionInformation } from '@aws-sdk/client-rekognitionstreaming';
+import type { ColorSequence } from './ColorSequenceDisplay';
 interface OvalBoundingBox {
     ovalBoundingBox: BoundingBox;
     minOvalX: number;
@@ -22,20 +20,21 @@ export declare function getIntersectionOverUnion(box1: BoundingBox, box2: Boundi
  * Returns the details of a randomly generated liveness oval
  * from SDK
  */
-export declare function getOvalDetailsFromSessionInformation({ sessionInformation, videoWidth, }: {
-    sessionInformation: SessionInformation;
+export declare function getOvalDetailsFromSessionInformation({ parsedSessionInformation, videoWidth, }: {
+    parsedSessionInformation: ParsedSessionInformation;
     videoWidth: number;
 }): LivenessOvalDetails;
 /**
  * Returns the details of a statically generated liveness oval based on the video dimensions
  */
-export declare function getStaticLivenessOvalDetails({ width, height, widthSeed, centerXSeed, centerYSeed, ratioMultiplier, }: {
+export declare function getStaticLivenessOvalDetails({ width, height, widthSeed, centerXSeed, centerYSeed, ratioMultiplier, ovalHeightWidthRatio, }: {
     width: number;
     height: number;
     widthSeed?: number;
     centerXSeed?: number;
     centerYSeed?: number;
     ratioMultiplier?: number;
+    ovalHeightWidthRatio?: number;
 }): LivenessOvalDetails;
 /**
  * Draws the provided liveness oval on the canvas.
@@ -51,7 +50,12 @@ export declare function drawStaticOval(canvasEl: HTMLCanvasElement, videoEl: HTM
 export declare function clearOvalCanvas({ canvas, }: {
     canvas: HTMLCanvasElement;
 }): void;
-export declare function generateBboxFromLandmarks(face: Face, oval: LivenessOvalDetails, frameHeight: number): BoundingBox;
+export declare function generateBboxFromLandmarks({ ovalHeightWidthRatio, face, oval, frameHeight, }: {
+    ovalHeightWidthRatio?: number;
+    face: Face;
+    oval: LivenessOvalDetails;
+    frameHeight: number;
+}): BoundingBox;
 /**
  * Returns the illumination state in the provided video frame.
  */
@@ -83,31 +87,16 @@ interface FillOverlayCanvasFractionalInput {
     scaleFactor: number;
 }
 export declare function fillOverlayCanvasFractional({ overlayCanvas, prevColor, nextColor, videoEl, ovalDetails, heightFraction, scaleFactor, }: FillOverlayCanvasFractionalInput): void;
-export declare const isClientFreshnessColorSequence: (obj: ClientFreshnessColorSequence | undefined) => obj is ClientFreshnessColorSequence;
-export declare function getColorsSequencesFromSessionInformation(sessionInformation: SessionInformation): ClientFreshnessColorSequence[];
-export declare function getRGBArrayFromColorString(colorStr: string): number[];
+export declare function getColorsSequencesFromSessionInformation(parsedSessionInformation: ParsedSessionInformation): ColorSequence[];
 export declare function getFaceMatchState(faceDetector: FaceDetection, videoEl: HTMLVideoElement): Promise<FaceMatchState>;
-export declare function isFaceDistanceBelowThreshold({ faceDetector, videoEl, ovalDetails, reduceThreshold, isMobile, }: {
+export declare function isFaceDistanceBelowThreshold({ parsedSessionInformation, faceDetector, videoEl, ovalDetails, reduceThreshold, }: {
+    parsedSessionInformation: ParsedSessionInformation;
     faceDetector: FaceDetection;
     videoEl: HTMLVideoElement;
     ovalDetails: LivenessOvalDetails;
     reduceThreshold?: boolean;
-    isMobile?: boolean;
 }): Promise<{
     isDistanceBelowThreshold: boolean;
     error?: ErrorState;
 }>;
-export declare function getBoundingBox({ deviceHeight, deviceWidth, height, width, top, left, }: {
-    deviceHeight: number;
-    deviceWidth: number;
-    height: number;
-    width: number;
-    top: number;
-    left: number;
-}): {
-    Height: number;
-    Width: number;
-    Top: number;
-    Left: number;
-};
 export {};

package/dist/types/components/FaceLivenessDetector/service/utils/{eventUtils.d.ts → responseStreamEvent.d.ts}

@@ -1,5 +1,5 @@
 import type { LivenessResponseStream } from '@aws-sdk/client-rekognitionstreaming';
-export declare const isServerSesssionInformationEvent: (value: unknown) => value is LivenessResponseStream.ServerSessionInformationEventMember;
+export declare const isServerSessionInformationEvent: (value: unknown) => value is LivenessResponseStream.ServerSessionInformationEventMember;
 export declare const isConnectionTimeoutError: (error: unknown) => error is Error;
 export declare const isDisconnectionEvent: (value: unknown) => value is LivenessResponseStream.DisconnectionEventMember;
 export declare const isValidationExceptionEvent: (value: unknown) => value is LivenessResponseStream.ValidationExceptionMember;

package/dist/types/components/FaceLivenessDetector/service/utils/sessionInformation.d.ts

@@ -0,0 +1,7 @@
+import type { FaceMovementServerChallenge, FaceMovementAndLightServerChallenge, SessionInformation as ServerSessionInformation } from '@aws-sdk/client-rekognitionstreaming';
+import type { FaceMovementAndLightChallenge, FaceMovementChallenge, ParsedSessionInformation } from '../types';
+export declare const isFaceMovementAndLightChallenge: (value: unknown) => value is FaceMovementAndLightChallenge;
+export declare const isFaceMovementChallenge: (value: unknown) => value is FaceMovementChallenge;
+export declare const isFaceMovementAndLightServerChallenge: (value: unknown) => value is FaceMovementAndLightServerChallenge;
+export declare const isFaceMovementServerChallenge: (value: unknown) => value is FaceMovementServerChallenge;
+export declare const createSessionInfoFromServerSessionInformation: (serverSessionInformation: ServerSessionInformation) => ParsedSessionInformation;

package/dist/types/components/FaceLivenessDetector/service/utils/types.d.ts

@@ -0,0 +1,21 @@
+import type { ClientSessionInformationEvent, LivenessRequestStream } from '@aws-sdk/client-rekognitionstreaming';
+export interface RequestStream extends AsyncGenerator<LivenessRequestStream> {
+}
+export interface VideoStream extends ReadableStream<StreamResult> {
+}
+export type StreamResultType = 'closeCode' | 'sessionInfo' | 'streamStop' | 'streamVideo';
+export type StreamResult<T extends StreamResultType = StreamResultType> = T extends 'closeCode' ? {
+    type: T;
+    data: {
+        closeCode: number;
+    };
+} : T extends 'streamVideo' ? {
+    type: T;
+    data: Blob;
+} : T extends 'sessionInfo' ? {
+    type: T;
+    data: ClientSessionInformationEvent;
+} : T extends 'streamStop' ? {
+    type: T;
+    data?: never;
+} : never;

package/dist/types/components/FaceLivenessDetector/types/classNames.d.ts

@@ -2,6 +2,8 @@ export declare enum LivenessClassNames {
     CameraModule = "amplify-liveness-camera-module",
     CancelContainer = "amplify-liveness-cancel-container",
     CancelButton = "amplify-liveness-cancel-button",
+    CenteredLoader = "amplify-liveness-centered-loader",
+    ConnectingLoader = "amplify-liveness-connecting-loader",
     CountdownContainer = "amplify-liveness-countdown-container",
     DescriptionBullet = "amplify-liveness-description-bullet",
     DescriptionBulletIndex = "amplify-liveness-description-bullet__index",
@@ -41,6 +43,7 @@ export declare enum LivenessClassNames {
     Toast = "amplify-liveness-toast",
     ToastContainer = "amplify-liveness-toast__container",
     ToastMessage = "amplify-liveness-toast__message",
+    UserFacingVideo = "amplify-liveness-video--user-facing",
     Video = "amplify-liveness-video",
     VideoAnchor = "amplify-liveness-video-anchor"
 }

package/dist/types/components/FaceLivenessDetector/utils/device.d.ts

@@ -1,4 +1,5 @@
 export declare function isMobileScreen(): boolean;
+export declare function isDeviceUserFacing(deviceId: string | undefined): Promise<boolean>;
 export declare function isIOS(): boolean;
 export declare function isPortrait(): boolean;
 /**

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "3.3.9";
+export declare const VERSION = "3.4.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/ui-react-liveness",
-  "version": "3.3.9",
+  "version": "3.4.1",
   "main": "dist/index.js",
   "module": "dist/esm/index.mjs",
   "exports": {
@@ -50,13 +50,13 @@
   "dependencies": {
     "@aws-amplify/ui": "6.10.3",
     "@aws-amplify/ui-react": "6.11.2",
-    "@aws-sdk/client-rekognitionstreaming": "3.621.0",
+    "@aws-sdk/client-rekognitionstreaming": "3.828.0",
     "@aws-sdk/util-format-url": "3.609.0",
-    "@smithy/eventstream-serde-browser": "^2.0.4",
-    "@smithy/fetch-http-handler": "^2.1.3",
+    "@smithy/eventstream-serde-browser": "^4.0.4",
+    "@smithy/fetch-http-handler": "^5.0.4",
     "@smithy/protocol-http": "^3.0.3",
-    "@smithy/signature-v4": "2.1.4",
-    "@smithy/types": "^3.3.0",
+    "@smithy/signature-v4": "5.1.2",
+    "@smithy/types": "^4.3.1",
     "@mediapipe/face_detection": "~0.4.0",
     "@tensorflow-models/face-detection": "1.0.2",
     "@tensorflow/tfjs-backend-cpu": "4.11.0",
@@ -64,8 +64,8 @@
     "@tensorflow/tfjs-converter": "4.11.0",
     "@tensorflow/tfjs-core": "4.11.0",
     "@xstate/react": "^3.2.2",
-    "nanoid": "3.3.8",
     "tslib": "^2.5.2",
+    "uuid": "^11.1.0",
     "xstate": "^4.33.6"
   },
   "devDependencies": {
@@ -85,4 +85,4 @@
       "limit": "225 kB"
     }
   ]
-}
+}