@aws-amplify/ui-react-liveness 0.0.0-next-43a297e-20230410194306

package/dist/styles.js

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { FaceLivenessDetectorProps as FaceLivenessDetectorPropsFromUi } from './service';
+import { StartScreenComponents } from './shared/DefaultStartScreenComponents';
+import { LivenessDisplayText } from './displayText';
+import { CheckScreenComponents } from './shared/FaceLivenessErrorModal';
+declare type FaceLivenessDetectorComponents = StartScreenComponents & CheckScreenComponents;
+export interface FaceLivenessDetectorProps extends FaceLivenessDetectorPropsFromUi {
+    components?: FaceLivenessDetectorComponents;
+    displayText?: LivenessDisplayText;
+}
+export default function FaceLivenessDetector(props: FaceLivenessDetectorProps): JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { FaceMatchState } from '../service';
+import { ErrorDisplayText, HintDisplayText, StreamDisplayText } from '../displayText';
+import { CheckScreenComponents } from '../shared/FaceLivenessErrorModal';
+export declare const selectVideoConstraints: import("../hooks").LivenessSelectorFn<MediaTrackConstraints>;
+export declare const selectVideoStream: import("../hooks").LivenessSelectorFn<MediaStream>;
+export declare const selectFaceMatchPercentage: import("../hooks").LivenessSelectorFn<number>;
+export declare const selectFaceMatchState: import("../hooks").LivenessSelectorFn<FaceMatchState>;
+export interface LivenessCameraModuleProps {
+    isMobileScreen: boolean;
+    isRecordingStopped: boolean;
+    streamDisplayText: Required<StreamDisplayText>;
+    hintDisplayText: Required<HintDisplayText>;
+    errorDisplayText: Required<ErrorDisplayText>;
+    components?: CheckScreenComponents;
+    testId?: string;
+}
+export declare const LivenessCameraModule: (props: LivenessCameraModuleProps) => JSX.Element;

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

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { LivenessErrorState } from '../service';
+import { HintDisplayText, CameraDisplayText, StreamDisplayText, ErrorDisplayText } from '../displayText';
+import { CheckScreenComponents } from '../shared/FaceLivenessErrorModal';
+export declare const selectErrorState: import("../hooks").LivenessSelectorFn<LivenessErrorState | null>;
+export declare const selectIsRecordingStopped: import("../hooks").LivenessSelectorFn<boolean>;
+interface LivenessCheckProps {
+    hintDisplayText: Required<HintDisplayText>;
+    cameraDisplayText: Required<CameraDisplayText>;
+    streamDisplayText: Required<StreamDisplayText>;
+    errorDisplayText: Required<ErrorDisplayText>;
+    components?: CheckScreenComponents;
+}
+export declare const LivenessCheck: React.FC<LivenessCheckProps>;
+export {};

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

@@ -0,0 +1 @@
+export * from './LivenessCheck';

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { InstructionDisplayText } from '../displayText';
+import { StartScreenComponents } from '../shared/DefaultStartScreenComponents';
+export interface StartLivenessProps {
+    beginLivenessCheck: () => void;
+    components?: StartScreenComponents;
+    instructionDisplayText: Required<InstructionDisplayText>;
+}
+export declare function StartLiveness(props: StartLivenessProps): JSX.Element;

package/dist/types/components/FaceLivenessDetector/StartLiveness/helpers.d.ts

@@ -0,0 +1 @@
+export declare function getVideoConstraints(): MediaTrackConstraints | null;

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

@@ -0,0 +1 @@
+export * from './StartLiveness';

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

@@ -0,0 +1,62 @@
+export declare type HintDisplayText = {
+    hintMoveFaceFrontOfCameraText?: string;
+    hintTooManyFacesText?: string;
+    hintFaceDetectedText?: string;
+    hintCanNotIdentifyText?: string;
+    hintTooCloseText?: string;
+    hintTooFarText?: string;
+    hintHoldFacePositionCountdownText?: string;
+    hintConnectingText?: string;
+    hintVerifyingText?: string;
+    hintIlluminationTooBrightText?: string;
+    hintIlluminationTooDarkText?: string;
+    hintIlluminationNormalText?: string;
+    hintHoldFaceForFreshnessText?: string;
+};
+export declare type CameraDisplayText = {
+    cameraMinSpecificationsHeadingText?: string;
+    cameraMinSpecificationsMessageText?: string;
+    cameraNotFoundHeadingText?: string;
+    cameraNotFoundMessageText?: string;
+    retryCameraPermissionsText?: string;
+};
+export declare type InstructionDisplayText = {
+    instructionsHeaderHeadingText?: string;
+    instructionsHeaderBodyText?: string;
+    instructionsBeginCheckText?: string;
+    photosensitivyWarningHeadingText?: string;
+    photosensitivyWarningBodyText?: string;
+    photosensitivyWarningInfoText?: string;
+    instructionListHeadingText?: string;
+    goodFitCaptionText?: string;
+    goodFitAltText?: string;
+    tooFarCaptionText?: string;
+    tooFarAltText?: string;
+    instructionListStepOneText?: string;
+    instructionListStepTwoText?: string;
+    instructionListStepThreeText?: string;
+    instructionListStepFourText?: string;
+};
+export declare type StreamDisplayText = {
+    recordingIndicatorText?: string;
+    cancelLivenessCheckText?: string;
+};
+export declare const defaultErrorDisplayText: {
+    timeoutHeaderText: string;
+    timeoutMessageText: string;
+    faceDistanceHeaderText: string;
+    faceDistanceMessageText: string;
+    clientHeaderText: string;
+    clientMessageText: string;
+    serverHeaderText: string;
+    serverMessageText: string;
+    landscapeHeaderText: string;
+    landscapeMessageText: string;
+    portraitMessageText: string;
+    tryAgainText: string;
+};
+export declare type ErrorDisplayTextFoo = typeof defaultErrorDisplayText;
+export declare type ErrorDisplayText = Partial<ErrorDisplayTextFoo>;
+export declare const defaultLivenessDisplayText: Required<LivenessDisplayText>;
+export interface LivenessDisplayText extends HintDisplayText, CameraDisplayText, InstructionDisplayText, ErrorDisplayText, StreamDisplayText {
+}

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

@@ -0,0 +1,3 @@
+export * from './useLivenessActor';
+export * from './useLivenessSelector';
+export * from './useMediaStreamInVideo';

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

@@ -0,0 +1 @@
+export declare function useLivenessActor(): [import("xstate").State<import("../service").LivenessContext, import("../service").LivenessEvent, any, any, any>, (event: import("xstate").SingleOrArray<import("xstate").Event<import("../service").LivenessEvent>> | import("xstate").SCXML.Event<import("../service").LivenessEvent>, payload?: import("xstate").EventData | undefined) => import("xstate").State<import("../service").LivenessContext, import("../service").LivenessEvent, any, any, any>];

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

@@ -0,0 +1,4 @@
+import { LivenessMachineState } from '../service';
+export declare 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/hooks/useMediaStreamInVideo.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export interface UseMediaStreamInVideo {
+    videoRef: React.MutableRefObject<HTMLVideoElement | null>;
+    videoHeight: number | undefined;
+    videoWidth: number | undefined;
+}
+export declare function useMediaStreamInVideo(stream: MediaStream, videoConstraints: MediaTrackConstraints): UseMediaStreamInVideo;

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

@@ -0,0 +1 @@
+export { default as FaceLivenessDetector, FaceLivenessDetectorProps, } from './FaceLivenessDetector';

package/dist/types/components/FaceLivenessDetector/providers/FaceLivenessDetectorProvider.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { LivenessInterpreter, FaceLivenessDetectorProps } from '../service';
+interface FaceLivenessDetectorContextType {
+    componentProps: FaceLivenessDetectorProps;
+    service: LivenessInterpreter;
+}
+export interface FaceLivenessDetectorProviderProps extends FaceLivenessDetectorContextType {
+    children?: React.ReactNode;
+}
+export declare function FaceLivenessDetectorProvider({ children, ...props }: FaceLivenessDetectorProviderProps): JSX.Element;
+export declare function useFaceLivenessDetector(): FaceLivenessDetectorContextType;
+export {};

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

@@ -0,0 +1 @@
+export * from './FaceLivenessDetectorProvider';

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

@@ -0,0 +1,3 @@
+export * from './machine';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,6 @@
+import { LivenessContext, LivenessEvent } from '../types';
+export declare const MIN_FACE_MATCH_TIME = 500;
+export declare const livenessMachine: import("xstate").StateMachine<LivenessContext, any, LivenessEvent, {
+    value: any;
+    context: TContext;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, LivenessEvent, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

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

@@ -0,0 +1,36 @@
+/**
+ * The bounding box of a face.
+ */
+export interface Face {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    timestampMs: number;
+    probability?: number;
+    rightEye: number[];
+    leftEye: number[];
+    mouth: number[];
+    nose: number[];
+}
+/**
+ * The abstract class representing FaceDetection
+ * to be implemented for different libraries.
+ */
+export declare abstract class FaceDetection {
+    modelLoadingPromise: Promise<void>;
+    /**
+     * Triggers the `loadModels` method and stores
+     * the corresponding promise to be awaited later.
+     */
+    triggerModelLoading(): void;
+    /**
+     * Loads the face detection models.
+     */
+    abstract loadModels(): Promise<void>;
+    /**
+     * Detects the faces in the video element.
+     * @param videoEl The video element to detect faces in.
+     */
+    abstract detectFaces(videoEl: HTMLVideoElement): Promise<Face[]>;
+}

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

@@ -0,0 +1,3 @@
+export * from './faceDetection';
+export * from './liveness';
+export * from './machine';

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

@@ -0,0 +1,98 @@
+/**
+ * The props for the FaceLivenessDetector
+ */
+export interface FaceLivenessDetectorProps {
+    /**
+     * The sessionId as returned by CreateStreamingLivenessSession API
+     */
+    sessionId: string;
+    /**
+     * Callback that signals when the liveness session has completed analysis.
+     * At this point a request can be made to GetFaceLivenessSessionResults.
+     */
+    onAnalysisComplete: () => Promise<void>;
+    /**
+     * The AWS region to stream the video to, for current regional support see the documentation here: FIXME LINK
+     */
+    region: string;
+    /**
+     * Callback called when the user cancels the flow
+     */
+    onUserCancel?: () => void;
+    /**
+     * Callback called when there is error occured on any step
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Optional parameter for the disabling the Start/Get Ready Screen, default: false
+     */
+    disableInstructionScreen?: boolean;
+    /**
+     * Optional parameter for advanced options for the component
+     */
+    config?: FaceLivenessDetectorConfig;
+}
+export interface FaceLivenessDetectorConfig {
+    /**
+     * overrides the Wasm backend binary CDN path
+     * default is https://cdn.jsdelivr.net/npm/@tensorflow/tfjs-backend-wasm@3.11.0/dist/.
+     * When overriding this path ensure that the wasm version matches the version of @tensorflow/tfjs-backend-wasm installed by npm
+     */
+    binaryPath?: string;
+    /**
+     * overrides the Blazeface model and weights bin CDN URL
+     * default is https://tfhub.dev/tensorflow/tfjs-model/blazeface/1/default/1/model.json?tfjs-format=file
+     */
+    faceModelUrl?: string;
+}
+/**
+ * The coordiates of any bounding box
+ */
+export interface BoundingBox {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * The details of the generated liveness oval
+ */
+export interface LivenessOvalDetails {
+    flippedCenterX: number | undefined;
+    centerX: number | undefined;
+    centerY: number | undefined;
+    width: number | undefined;
+    height: number | undefined;
+}
+/**
+ * The illumination states
+ */
+export declare enum IlluminationState {
+    DARK = "dark",
+    BRIGHT = "bright",
+    NORMAL = "normal"
+}
+/**
+ * The detected face states with respect to the liveness oval
+ */
+export declare enum FaceMatchState {
+    MATCHED = "MATCHED",
+    TOO_FAR = "TOO FAR",
+    TOO_CLOSE = "TOO CLOSE",
+    CANT_IDENTIFY = "CANNOT IDENTIFY",
+    FACE_IDENTIFIED = "ONE FACE IDENTIFIED",
+    TOO_MANY = "TOO MANY FACES"
+}
+/**
+ * The liveness error states
+ */
+export declare enum LivenessErrorState {
+    TIMEOUT = "TIMEOUT",
+    RUNTIME_ERROR = "RUNTIME_ERROR",
+    FRESHNESS_TIMEOUT = "FRESHNESS_TIMEOUT",
+    SERVER_ERROR = "SERVER_ERROR",
+    CAMERA_FRAMERATE_ERROR = "CAMERA_FRAMERATE_ERROR",
+    CAMERA_ACCESS_ERROR = "CAMERA_ACCESS_ERROR",
+    FACE_DISTANCE_ERROR = "FACE_DISTANCE_ERROR",
+    MOBILE_LANDSCAPE_ERROR = "MOBILE_LANDSCAPE_ERROR"
+}

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

@@ -0,0 +1,102 @@
+import { ActorRef, Interpreter, State } from 'xstate';
+import { ValidationException, InternalServerException, ThrottlingException, ServiceQuotaExceededException, SessionInformation } from '@aws-sdk/client-rekognitionstreaming';
+import { FaceLivenessDetectorProps, FaceMatchState, LivenessErrorState, LivenessOvalDetails, IlluminationState } from './liveness';
+import { VideoRecorder, LivenessStreamProvider, FreshnessColorDisplay } from '../utils';
+import { Face, FaceDetection } from './faceDetection';
+export interface FaceMatchAssociatedParams {
+    illuminationState: IlluminationState;
+    faceMatchState: FaceMatchState;
+    faceMatchPercentage: number;
+    currentDetectedFace: Face;
+    startFace: Face;
+    endFace: Face;
+    initialFaceMatchTime: number;
+}
+export interface FreshnessColorAssociatedParams {
+    freshnessColorEl: HTMLCanvasElement;
+    freshnessColors: string[];
+    freshnessColorsComplete: boolean;
+    freshnessColorDisplay: FreshnessColorDisplay;
+}
+export interface OvalAssociatedParams {
+    faceDetector: FaceDetection;
+    initialFace: Face;
+    ovalDetails: LivenessOvalDetails;
+    scaleFactor: number;
+}
+export interface VideoAssociatedParams {
+    videoConstraints: MediaTrackConstraints;
+    videoEl: HTMLVideoElement;
+    canvasEl: HTMLCanvasElement;
+    videoMediaStream: MediaStream;
+    videoRecorder: VideoRecorder;
+    recordingStartTimestampMs: number;
+    isMobile: boolean | undefined;
+}
+export interface LivenessContext {
+    maxFailedAttempts: number;
+    failedAttempts: number;
+    componentProps: FaceLivenessDetectorProps;
+    serverSessionInformation: SessionInformation;
+    challengeId: string;
+    videoAssociatedParams: VideoAssociatedParams;
+    ovalAssociatedParams: OvalAssociatedParams;
+    faceMatchAssociatedParams: FaceMatchAssociatedParams;
+    freshnessColorAssociatedParams: FreshnessColorAssociatedParams;
+    errorState: LivenessErrorState | null;
+    livenessStreamProvider: LivenessStreamProvider;
+    responseStreamActorRef: ActorRef<any>;
+    shouldDisconnect: boolean | undefined;
+    faceMatchStateBeforeStart: FaceMatchState;
+    isFaceFarEnoughBeforeRecording: boolean;
+    isRecordingStopped: boolean;
+}
+export declare type LivenessEventTypes = 'BEGIN' | 'START_RECORDING' | 'TIMEOUT' | 'ERROR' | 'CANCEL' | 'SET_SESSION_INFO' | 'DISCONNECT_EVENT' | 'SET_DOM_AND_CAMERA_DETAILS' | 'SERVER_ERROR' | 'RETRY_CAMERA_CHECK' | 'MOBILE_LANDSCAPE_WARNING';
+export declare type LivenessEventData = Record<PropertyKey, any>;
+export interface LivenessEvent {
+    type: LivenessEventTypes;
+    data?: LivenessEventData;
+}
+export declare type LivenessMachineState = State<LivenessContext, LivenessEvent>;
+export declare type LivenessInterpreter = Interpreter<LivenessContext, any, LivenessEvent, any, any>;
+export interface StreamActorCallback {
+    (params: {
+        type: 'DISCONNECT_EVENT';
+    }): void;
+    (params: {
+        type: 'SERVER_ERROR';
+        data: {
+            error: Error;
+        };
+    }): void;
+    (params: {
+        type: 'SERVER_ERROR';
+        data: {
+            error: ValidationException;
+        };
+    }): void;
+    (params: {
+        type: 'SERVER_ERROR';
+        data: {
+            error: InternalServerException;
+        };
+    }): void;
+    (params: {
+        type: 'SERVER_ERROR';
+        data: {
+            error: ThrottlingException;
+        };
+    }): void;
+    (params: {
+        type: 'SERVER_ERROR';
+        data: {
+            error: ServiceQuotaExceededException;
+        };
+    }): void;
+    (params: {
+        type: 'SET_SESSION_INFO';
+        data: {
+            sessionInfo: SessionInformation | undefined;
+        };
+    }): void;
+}

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

@@ -0,0 +1,74 @@
+export declare enum ChallengeType {
+    FACE_MOVEMENT = "FACE_MOVEMENT"
+}
+export interface OvalParameters {
+    width: number;
+    centerX: number;
+    centerY: number;
+}
+export interface ClientFaceMovementAndLightChallenge {
+    ovalParameters: OvalParameters;
+}
+export interface ClientChallenge {
+    faceMovementAndLightChallenge: ClientFaceMovementAndLightChallenge;
+}
+export interface SessionInformation {
+    challenge: ClientChallenge;
+}
+export interface BoundingBoxWithSize {
+    height: number;
+    width: number;
+    top: number;
+    left: number;
+}
+export interface RecordingTimestamps {
+    videoStart: number;
+    initialFaceDetected: number;
+    faceDetectedInTargetPositionStart: number;
+    faceDetectedInTargetPositionEnd: number;
+}
+export declare enum Color {
+    BLACK = "rgb(0, 0, 0)",
+    WHITE = "rgb(255, 255, 255)",
+    RED = "rgb(255, 0, 0)",
+    YELLOW = "rgb(255, 255, 0)",
+    LIME = "rgb(0, 255, 0)",
+    CYAN = "rgb(0, 255, 255)",
+    BLUE = "rgb(0, 0, 255)",
+    VIOLET = "rgb(255, 0, 255)"
+}
+export declare enum FreshnessColor {
+    BLACK = "rgb_0_0_0",
+    BLUE = "rgb_0_0_255",
+    CYAN = "rgb_0_255_255",
+    LIME = "rgb_0_255_0",
+    RED = "rgb_255_0_0",
+    VIOLET = "rgb_255_0_255",
+    WHITE = "rgb_255_255_255",
+    YELLOW = "rgb_255_255_0"
+}
+export interface ClientFreshnessColorSequence {
+    color: string;
+    downscrollDuration: number;
+    flatDisplayDuration: number;
+}
+export interface ColorSequence {
+    colorTimestampList: ColorTimestamp[];
+}
+export interface ColorTimestamp {
+    color: Color;
+    timestamp: number;
+}
+export interface ServerFaceMovementAndLightChallenge {
+    challengeId: string;
+    initialFacePosition: BoundingBoxWithSize;
+    targetFacePosition: BoundingBoxWithSize;
+    recordingTimestamps: RecordingTimestamps;
+    colorSequence: ColorSequence;
+}
+export interface ServerChallenge {
+    faceMovementAndLightChallenge: ServerFaceMovementAndLightChallenge;
+}
+export interface ClientSessionInformation {
+    challenge: ServerChallenge;
+}

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

@@ -0,0 +1,18 @@
+import '@tensorflow/tfjs-backend-cpu';
+import { FaceDetection, Face } from '../types';
+declare type BlazeFaceModelBackend = 'wasm' | 'cpu';
+/**
+ * The BlazeFace implementation of the FaceDetection interface.
+ */
+export declare class BlazeFaceFaceDetection extends FaceDetection {
+    modelBackend: BlazeFaceModelBackend;
+    faceModelUrl: string | undefined;
+    binaryPath: string;
+    private _model;
+    constructor(binaryPath?: string, faceModelUrl?: string);
+    loadModels(): Promise<void>;
+    detectFaces(videoEl: HTMLVideoElement): Promise<Face[]>;
+    private _loadWebAssemblyBackend;
+    private _loadCPUBackend;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export declare const FACE_DISTANCE_THRESHOLD = 0.32;
+export declare const REDUCED_THRESHOLD = 0.4;
+export declare const REDUCED_THRESHOLD_MOBILE = 0.37;

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

@@ -0,0 +1,12 @@
+import { FaceMovementAndLightServerChallenge, LivenessResponseStream, OvalParameters, ServerChallenge, SessionInformation } from '@aws-sdk/client-rekognitionstreaming';
+export declare const isServerSesssionInformationEvent: (value: unknown) => value is LivenessResponseStream.ServerSessionInformationEventMember;
+export declare const isOvalParameters: (value: unknown) => value is OvalParameters;
+export declare const isFaceMovementAndLightChallenge: (value: unknown) => value is FaceMovementAndLightServerChallenge;
+export declare const isServerChallenge: (value: unknown) => value is ServerChallenge;
+export declare const isSessionInformation: (value: unknown) => value is SessionInformation;
+export declare const isDisconnectionEvent: (value: unknown) => value is LivenessResponseStream.DisconnectionEventMember;
+export declare const isValidationExceptionEvent: (value: unknown) => value is LivenessResponseStream.ValidationExceptionMember;
+export declare const isInternalServerExceptionEvent: (value: unknown) => value is LivenessResponseStream.InternalServerExceptionMember;
+export declare const isThrottlingExceptionEvent: (value: unknown) => value is LivenessResponseStream.ThrottlingExceptionMember;
+export declare const isServiceQuotaExceededExceptionEvent: (value: unknown) => value is LivenessResponseStream.ServiceQuotaExceededExceptionMember;
+export declare const isInvalidSignatureRegionException: (error: unknown) => error is Error;

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

@@ -0,0 +1,22 @@
+import { LivenessContext } from '../types/machine';
+import { ClientFreshnessColorSequence } from '../types/service';
+export declare class FreshnessColorDisplay {
+    private freshnessColorsSequence;
+    private context;
+    private stageIndex;
+    private stage;
+    private currColorIndex;
+    private currColorSequence;
+    private prevColorSequence;
+    private timeLastFlatOrScrollChange;
+    private timeFaceMatched;
+    private timeLastFaceMatchChecked;
+    private isFirstTick;
+    constructor(context: LivenessContext, freshnessColorsSequence: ClientFreshnessColorSequence[]);
+    displayColorTick(): Promise<boolean>;
+    private init;
+    private displayNextColorTick;
+    private incrementStageIndex;
+    private matchFaceInOval;
+    private sendColorStartTime;
+}

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

@@ -0,0 +1,6 @@
+export * from './blazefaceFaceDetection';
+export * from './videoRecorder';
+export * from './support';
+export * from './liveness';
+export * from './streamProvider';
+export * from './freshnessColorDisplay';