@aws-amplify/ui-react-liveness 3.3.8 → 3.4.0

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/FaceLivenessDetector.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
-import { FaceLivenessDetectorProps as FaceLivenessDetectorPropsFromUi } from './service';
-import { LivenessDisplayText } from './displayText';
-import { FaceLivenessDetectorComponents } from './shared/DefaultStartScreenComponents';
+import type { FaceLivenessDetectorProps as FaceLivenessDetectorPropsFromUi } from './service';
+import type { LivenessDisplayText } from './displayText';
+import type { FaceLivenessDetectorComponents } from './shared/DefaultStartScreenComponents';
 export interface FaceLivenessDetectorProps extends FaceLivenessDetectorPropsFromUi {
     components?: FaceLivenessDetectorComponents;
     displayText?: LivenessDisplayText;

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

@@ -1,7 +1,7 @@
 import * as React from 'react';
-import { FaceLivenessDetectorCoreProps as FaceLivenessDetectorPropsFromUi } from './service';
-import { FaceLivenessDetectorComponents } from './shared/DefaultStartScreenComponents';
-import { LivenessDisplayText } from './displayText';
+import type { FaceLivenessDetectorCoreProps as FaceLivenessDetectorPropsFromUi } from './service';
+import type { FaceLivenessDetectorComponents } from './shared/DefaultStartScreenComponents';
+import type { LivenessDisplayText } from './displayText';
 export interface FaceLivenessDetectorCoreProps extends FaceLivenessDetectorPropsFromUi {
     components?: FaceLivenessDetectorComponents;
     displayText?: LivenessDisplayText;

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

@@ -1,7 +1,8 @@
 import React from 'react';
 import { FaceMatchState } from '../service';
-import { InstructionDisplayText, ErrorDisplayText, HintDisplayText, StreamDisplayText, CameraDisplayText } from '../displayText';
-import { FaceLivenessDetectorComponents } from '../shared/DefaultStartScreenComponents';
+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/LivenessCheck/LivenessCheck.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
-import { InstructionDisplayText, HintDisplayText, CameraDisplayText, StreamDisplayText, ErrorDisplayText } from '../displayText';
-import { FaceLivenessDetectorComponents } from '../shared/DefaultStartScreenComponents';
+import type { InstructionDisplayText, HintDisplayText, CameraDisplayText, StreamDisplayText, ErrorDisplayText } from '../displayText';
+import type { FaceLivenessDetectorComponents } from '../shared/DefaultStartScreenComponents';
 export declare const selectIsRecordingStopped: import("../hooks").LivenessSelectorFn<boolean | undefined>;
 interface LivenessCheckProps {
     instructionDisplayText: Required<InstructionDisplayText>;

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

@@ -1,4 +1,4 @@
-import { DisplayTextTemplate } from '@aws-amplify/ui';
+import type { DisplayTextTemplate } from '@aws-amplify/ui';
 export type HintDisplayText = {
     hintMoveFaceFrontOfCameraText?: string;
     hintTooManyFacesText?: string;

package/dist/types/components/FaceLivenessDetector/hooks/useLivenessSelector.d.ts

@@ -1,4 +1,4 @@
-import { LivenessMachineState } from '../service';
+import type { LivenessMachineState } from '../service';
 export type LivenessSelectorFn<T> = (state: LivenessMachineState) => T;
 export declare function createLivenessSelector<T>(selector: LivenessSelectorFn<T>): LivenessSelectorFn<T>;
 export declare function useLivenessSelector<T>(selector: LivenessSelectorFn<T>): T;

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

@@ -1,3 +1,6 @@
-export { default as FaceLivenessDetector, FaceLivenessDetectorProps, } from './FaceLivenessDetector';
-export { default as FaceLivenessDetectorCore, FaceLivenessDetectorCoreProps, } from './FaceLivenessDetectorCore';
-export { AwsCredentialProvider, AwsTemporaryCredentials, AwsCredentials, ErrorState, } from './service';
+export type { FaceLivenessDetectorProps } from './FaceLivenessDetector';
+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/providers/FaceLivenessDetectorProvider.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { LivenessInterpreter, FaceLivenessDetectorProps } from '../service';
+import type { LivenessInterpreter, FaceLivenessDetectorProps } from '../service';
 interface FaceLivenessDetectorContextType {
     componentProps: FaceLivenessDetectorProps;
     service: LivenessInterpreter;

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

@@ -1,4 +1,4 @@
-import { LivenessContext, LivenessEvent } from '../types';
+import type { LivenessContext, LivenessEvent } from '../types';
 export declare const livenessMachine: import("xstate").StateMachine<LivenessContext, any, LivenessEvent, {
     value: any;
     context: LivenessContext;

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

@@ -1,4 +1,4 @@
-import { CredentialsAndIdentityId } from 'aws-amplify/auth';
+import type { CredentialsAndIdentityId } from 'aws-amplify/auth';
 export type AwsCredentials = CredentialsAndIdentityId['credentials'];
 export interface IdentityProvider<IdentityT extends AwsCredentials> {
     (identityProperties?: Record<string, any>): Promise<IdentityT>;

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

@@ -1,5 +1,5 @@
-import { AwsCredentialProvider } from './credentials';
-import { ErrorState } from './error';
+import type { AwsCredentialProvider } from './credentials';
+import type { ErrorState } from './error';
 /**
  * The props for the FaceLivenessDetectorCore which allows for full configuration of auth
  */

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

@@ -1,9 +1,21 @@
-import { ActorRef, Interpreter, State } from 'xstate';
-import { ValidationException, InternalServerException, ThrottlingException, ServiceQuotaExceededException, SessionInformation } from '@aws-sdk/client-rekognitionstreaming';
-import { FaceLivenessDetectorCoreProps, FaceMatchState, LivenessOvalDetails, IlluminationState } from './liveness';
-import { ErrorState } from './error';
-import { VideoRecorder, LivenessStreamProvider, FreshnessColorDisplay } from '../utils';
-import { Face, FaceDetection } from './faceDetection';
+import type { ActorRef, Interpreter, State } from 'xstate';
+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 { 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/blazefaceFaceDetection.d.ts

@@ -1,5 +1,6 @@
 import '@tensorflow/tfjs-backend-cpu';
-import { FaceDetection, Face } from '../types';
+import type { Face } from '../types';
+import { FaceDetection } from '../types';
 type BlazeFaceModelBackend = 'wasm' | 'cpu';
 export declare const BLAZEFACE_VERSION = "1.0.2";
 /**

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/CustomWebSocketFetchHandler.d.ts

@@ -1,5 +1,6 @@
-import { HttpRequest, HttpResponse } from '@smithy/protocol-http';
-import { Provider, RequestHandler, RequestHandlerMetadata } from './types';
+import type { HttpRequest } from '@smithy/protocol-http';
+import { HttpResponse } from '@smithy/protocol-http';
+import type { Provider, RequestHandler, RequestHandlerMetadata } from './types';
 export declare const WEBSOCKET_CONNECTION_TIMEOUT_MESSAGE = "Websocket connection timeout";
 export interface WebSocketFetchHandlerOptions {
     /**

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

@@ -1,6 +1,5 @@
 import { SignatureV4 } from '@smithy/signature-v4';
-import { HttpRequest as HttpRequest, RequestPresigningArguments } from './types';
-export declare const REQUEST_EXPIRY = 299;
+import type { HttpRequest as HttpRequest, RequestPresigningArguments } from './types';
 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 { AwsCredentialProvider } from '../../types';
-interface CreateClientConfig {
-    credentialsProvider?: AwsCredentialProvider;
-    endpointOverride?: string;
+import type { LivenessRequestStream, LivenessResponseStream, StartFaceLivenessSessionCommandInput } from '@aws-sdk/client-rekognitionstreaming';
+import type { AwsCredentialProvider } from '../../types';
+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/createStreamingClient/resolveCredentials.d.ts

@@ -1,4 +1,4 @@
-import { AwsCredentialProvider, AwsCredentials } from '../../types';
+import type { AwsCredentialProvider, AwsCredentials } from '../../types';
 /**
  * Resolves the `credentials` param to be passed to `RekognitionStreamingClient` which accepts either:
  * - a `credentials` object

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

@@ -1 +1 @@
-export { HttpRequest, Provider, RequestHandler, RequestHandlerMetadata, RequestPresigningArguments, } from '@smithy/types';
+export type { HttpRequest, Provider, RequestHandler, RequestHandlerMetadata, RequestPresigningArguments, } from '@smithy/types';

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

@@ -1,16 +1,16 @@
-import { LivenessOvalDetails, Face, FaceMatchState } from '../types';
-import { SessionInformation } from '@aws-sdk/client-rekognitionstreaming';
+import type { Face, LivenessOvalDetails, ParsedSessionInformation } from '../types';
+import { FaceMatchState } from '../types';
 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';