@aws-sdk/client-rekognitionstreaming 3.306.0 → 3.309.0

package/dist-types/commands/StartFaceLivenessSessionCommand.d.ts

@@ -17,6 +17,115 @@ export interface StartFaceLivenessSessionCommandInput extends StartFaceLivenessS
  */
 export interface StartFaceLivenessSessionCommandOutput extends StartFaceLivenessSessionResponse, __MetadataBearer {
 }
+/**
+ * @public
+ * <p>Starts a Face Liveness video stream and liveness detection process for a given
+ *       session.</p>
+ *          <p>Requires <code>sessionId</code>, <code>ChallengeVersions</code>, <code>VideoWidth</code>,
+ *         <code>VideoHeight</code> and a <code>RequestEventStream</code> as input. The event stream
+ *       contains information about different events for the session, including the challenge
+ *       information used for verification. </p>
+ *          <p>The maximum video size for Face Liveness is 10 MB. Face Liveness throws a
+ *         <code>ValidationException</code> if the video does not match the necessary formatting and
+ *       size parameters. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RekognitionStreamingClient, StartFaceLivenessSessionCommand } from "@aws-sdk/client-rekognitionstreaming"; // ES Modules import
+ * // const { RekognitionStreamingClient, StartFaceLivenessSessionCommand } = require("@aws-sdk/client-rekognitionstreaming"); // CommonJS import
+ * const client = new RekognitionStreamingClient(config);
+ * const input = { // StartFaceLivenessSessionRequest
+ *   SessionId: "STRING_VALUE", // required
+ *   VideoWidth: "STRING_VALUE", // required
+ *   VideoHeight: "STRING_VALUE", // required
+ *   ChallengeVersions: "STRING_VALUE", // required
+ *   LivenessRequestStream: { // LivenessRequestStream Union: only one key present
+ *     VideoEvent: { // VideoEvent
+ *       VideoChunk: "BLOB_VALUE",
+ *       TimestampMillis: Number("long"),
+ *     },
+ *     ClientSessionInformationEvent: { // ClientSessionInformationEvent
+ *       Challenge: { // ClientChallenge Union: only one key present
+ *         FaceMovementAndLightChallenge: { // FaceMovementAndLightClientChallenge
+ *           ChallengeId: "STRING_VALUE", // required
+ *           VideoStartTimestamp: Number("long"),
+ *           VideoEndTimestamp: Number("long"),
+ *           InitialFace: { // InitialFace
+ *             BoundingBox: { // BoundingBox
+ *               Width: Number("float"), // required
+ *               Height: Number("float"), // required
+ *               Left: Number("float"), // required
+ *               Top: Number("float"), // required
+ *             },
+ *             InitialFaceDetectedTimestamp: Number("long"), // required
+ *           },
+ *           TargetFace: { // TargetFace
+ *             BoundingBox: {
+ *               Width: Number("float"), // required
+ *               Height: Number("float"), // required
+ *               Left: Number("float"), // required
+ *               Top: Number("float"), // required
+ *             },
+ *             FaceDetectedInTargetPositionStartTimestamp: Number("long"), // required
+ *             FaceDetectedInTargetPositionEndTimestamp: Number("long"), // required
+ *           },
+ *           ColorDisplayed: { // ColorDisplayed
+ *             CurrentColor: { // FreshnessColor
+ *               RGB: [ // ColorComponentList // required
+ *                 Number("int"),
+ *               ],
+ *             },
+ *             PreviousColor: {
+ *               RGB: [ // required
+ *                 Number("int"),
+ *               ],
+ *             },
+ *             SequenceNumber: Number("int"), // required
+ *             CurrentColorStartTimestamp: Number("long"), // required
+ *           },
+ *         },
+ *       },
+ *     },
+ *   },
+ * };
+ * const command = new StartFaceLivenessSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @param StartFaceLivenessSessionCommandInput - {@link StartFaceLivenessSessionCommandInput}
+ * @returns {@link StartFaceLivenessSessionCommandOutput}
+ * @see {@link StartFaceLivenessSessionCommandInput} for command's `input` shape.
+ * @see {@link StartFaceLivenessSessionCommandOutput} for command's `response` shape.
+ * @see {@link RekognitionStreamingClientResolvedConfig | config} for RekognitionStreamingClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>Occurs when the client isn't authorized to perform the action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>Unexpected error during processing of request.</p>
+ *
+ * @throws {@link ServiceQuotaExceededException} (client fault)
+ *  <p>Occurs when a request would cause a service quota to be exceeded.</p>
+ *
+ * @throws {@link ServiceUnavailableException} (server fault)
+ *  <p>Service-wide throttling to recover from an operational event or service is not able to scale.</p>
+ *
+ * @throws {@link SessionNotFoundException} (client fault)
+ *  <p>Occurs when the given <code>sessionId</code> is not found.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>A request was denied due to request throttling. Occurs when too many requests were made by a user
+ *        (exceeding their service quota), the service isn't able to scale, or a service-wide throttling was done to recover from an operational event.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The input fails to satisfy the constraints specified by the service. Potential reasons
+ *       inlcude: video quality or size is invalid, video container format not supported, video does
+ *       not have enough information - no person detected in video, request couldn't be parsed or is
+ *       invalid, session has expired or is invalid, S3 bucket is invalid/in another AWS region, KMS
+ *       Key is invalid.</p>
+ *
+ *
+ */
 export declare class StartFaceLivenessSessionCommand extends $Command<StartFaceLivenessSessionCommandInput, StartFaceLivenessSessionCommandOutput, RekognitionStreamingClientResolvedConfig> {
     readonly input: StartFaceLivenessSessionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;

package/dist-types/models/models_0.d.ts

@@ -2,6 +2,7 @@ import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-cl
 import { RekognitionStreamingServiceException as __BaseException } from "./RekognitionStreamingServiceException";
 /**
  * @public
+ * <p>Occurs when the client isn't authorized to perform the action.</p>
  */
 export declare class AccessDeniedException extends __BaseException {
     readonly name: "AccessDeniedException";
@@ -15,77 +16,199 @@ export declare class AccessDeniedException extends __BaseException {
 }
 /**
  * @public
+ * <p>Identifies the bounding box around a given label, face, text, object of interest, or
+ *       personal protective equipment. The left (x-coordinate) and top (y-coordinate) are coordinates
+ *       representing the top and left sides of the bounding box. Note that the upper-left corner of
+ *       the image is the origin (0,0). </p>
+ *          <p>The top and left values returned are ratios of the overall image size. For example, if the input image is 700x200 pixels, and the top-left coordinate of the bounding box is 350x50 pixels, the API returns a left value of 0.5 (350/700) and a top value of 0.25 (50/200).</p>
+ *          <p>The width and height values represent the dimensions of the bounding box as a ratio of the overall image dimension. For example, if the input image is 700x200 pixels, and the bounding box width is 70 pixels, the width returned is 0.1. </p>
  */
 export interface BoundingBox {
+    /**
+     * <p>Width of the bounding box as a ratio of the overall image width.</p>
+     */
     Width: number | undefined;
+    /**
+     * <p>Height of the bounding box as a ratio of the overall image height.</p>
+     */
     Height: number | undefined;
+    /**
+     * <p>Left coordinate of the bounding box as a ratio of overall image width.</p>
+     */
     Left: number | undefined;
+    /**
+     * <p>Top coordinate of the bounding box as a ratio of overall image height.</p>
+     */
     Top: number | undefined;
 }
 /**
  * @public
+ * <p>Configuration options for Face Liveness challenges performed at the client side. </p>
  */
 export interface ChallengeConfig {
+    /**
+     * <p>Threshold for face detection done using blaze face.</p>
+     */
     BlazeFaceDetectionThreshold?: number;
+    /**
+     * <p>Threshold for the minimum distance that face can be from the camera before face oval
+     *       match challenge starts.</p>
+     */
     FaceDistanceThresholdMin?: number;
+    /**
+     * <p>Threshold for face distance threshold face liveness challenge.</p>
+     */
     FaceDistanceThreshold?: number;
+    /**
+     * <p>Threshold for the maximum distance that face can be from the camera before face oval
+     *       match challenge starts.</p>
+     */
     FaceDistanceThresholdMax?: number;
+    /**
+     * <p>Threshold for face oval match using IoU (Intersection over Union).</p>
+     */
     OvalIouThreshold?: number;
+    /**
+     * <p>Height to width ratio of oval used for face oval match.</p>
+     */
     OvalHeightWidthRatio?: number;
+    /**
+     * <p>Threshold for width during oval IOU (Intersection over Union) match.</p>
+     */
     OvalIouWidthThreshold?: number;
+    /**
+     * <p>Threshold for height during oval IOU (Intersection over Union) match.</p>
+     */
     OvalIouHeightThreshold?: number;
+    /**
+     * <p>Threshold for width during face IOU (Intersection over Union) match.</p>
+     */
     FaceIouWidthThreshold?: number;
+    /**
+     * <p> Threshold for height during face IOU (Intersection over Union) match.</p>
+     */
     FaceIouHeightThreshold?: number;
 }
 /**
  * @public
+ * <p>Represents the colors to be flashed to the end user, each color represented in RGB values.</p>
  */
 export interface FreshnessColor {
+    /**
+     * <p>RGB values for a color to be flashed to the end user.</p>
+     */
     RGB: number[] | undefined;
 }
 /**
  * @public
+ * <p>Contains information regarding <code>SequenceNumber</code>, <code>CurrentColor</code>,
+ *         <code>PreviousColor</code>, and <code>CurrentColorStartTimestamp</code>.</p>
  */
 export interface ColorDisplayed {
+    /**
+     * <p> The current color being displayed on the screen (flat or downscrolled). It will contain a separate RGB list having 3 elements (each element can have values between 0 to 255). </p>
+     */
     CurrentColor: FreshnessColor | undefined;
+    /**
+     * <p>The previous color displayed on screen (flat or downscrolled). It will contain a separate RGB list having 3 elements (each element can have values between 0 to 255). </p>
+     */
     PreviousColor?: FreshnessColor;
+    /**
+     * <p>The order in which the current color was displayed on the screen.</p>
+     */
     SequenceNumber: number | undefined;
+    /**
+     * <p>Epoch timestamp of when the current color was displayed on the user screen.</p>
+     */
     CurrentColorStartTimestamp: number | undefined;
 }
 /**
  * @public
+ * <p> Contains bounding box of initial face position of the user on the device screen.
+ *       Contains an epoch timestamp of when the user was detected in this position. Used for Face
+ *       Liveness detection.</p>
  */
 export interface InitialFace {
+    /**
+     * <p>The bounding box for the initial face position of the user on the device screen.</p>
+     */
     BoundingBox: BoundingBox | undefined;
+    /**
+     * <p>Timestamp that a face was initially detected at.</p>
+     */
     InitialFaceDetectedTimestamp: number | undefined;
 }
 /**
  * @public
+ * <p>Contains bounding box of face position of the user on the device screen at target
+ *       location constructed for the challenge. This is generated using the random offsets provided by
+ *       the server to the client at session start. Also contains start and end epoch timestamp of when
+ *       the user was detected in this position.</p>
  */
 export interface TargetFace {
+    /**
+     * <p>A bounding box for the target face.</p>
+     */
     BoundingBox: BoundingBox | undefined;
+    /**
+     * <p>Starting timestamp at which a face was detected in the target position.</p>
+     */
     FaceDetectedInTargetPositionStartTimestamp: number | undefined;
+    /**
+     * <p>Ending timestamp at which a face was detected in the target position.</p>
+     */
     FaceDetectedInTargetPositionEndTimestamp: number | undefined;
 }
 /**
  * @public
+ * <p>Holds information about the type of face movement and light challenges that need to be
+ *       performed.</p>
  */
 export interface FaceMovementAndLightClientChallenge {
+    /**
+     * <p>An ID that uniquely identifies a challenge from a client.</p>
+     */
     ChallengeId: string | undefined;
+    /**
+     * <p>Epoch timestamp indicating start of video recording.</p>
+     */
     VideoStartTimestamp?: number;
+    /**
+     * <p>Epoch timestamp indicating end of video recording.</p>
+     */
     VideoEndTimestamp?: number;
+    /**
+     * <p>Contains the bounding box of the initial face position for the user on the device screen.
+     *       Also contains an epoch timestamp of when the user was detected in this position. Used for Face
+     *       Liveness detection.</p>
+     */
     InitialFace?: InitialFace;
+    /**
+     * <p>Contains the face position bounding box for the user on the device's screen, set at the
+     *       target location constructed for the challenge. Generated using a precise oval location
+     *       depending on the provided video </p>
+     *          <p>dimensions in the input stream. Contains start and end epoch timestamp of when the user
+     *       was detected in this position.</p>
+     */
     TargetFace?: TargetFace;
+    /**
+     * <p>Contains information regarding SequenceNumber, CurrentColor, PreviousColor, and CurrentColorStartTimestamp for a challenge.</p>
+     */
     ColorDisplayed?: ColorDisplayed;
 }
 /**
  * @public
+ * <p>Object containing information for Face Liveness challenges performed at the client
+ *       side.</p>
  */
 export type ClientChallenge = ClientChallenge.FaceMovementAndLightChallengeMember | ClientChallenge.$UnknownMember;
 /**
  * @public
  */
 export declare namespace ClientChallenge {
+    /**
+     * <p>Information about a face movement and light challenge type.</p>
+     */
     interface FaceMovementAndLightChallengeMember {
         FaceMovementAndLightChallenge: FaceMovementAndLightClientChallenge;
         $unknown?: never;
@@ -102,22 +225,42 @@ export declare namespace ClientChallenge {
 }
 /**
  * @public
+ * <p>Any information that the client needs to send for the streaming session. For face movement challenge,
+ *        it will contain information like initial face position and target face position.</p>
  */
 export interface ClientSessionInformationEvent {
+    /**
+     * <p>Contains information on FaceMovementAndLightChellenge, TargetFace, and ColorDisplayed, for a given Challenge.</p>
+     */
     Challenge: ClientChallenge | undefined;
 }
 /**
  * @public
+ * <p>A color sequence to be displayed on the user’s screen. </p>
  */
 export interface ColorSequence {
+    /**
+     * <p>Represents the colors in a given ColorSequence to be flashed to the end user, with each color represented in RGB values.</p>
+     */
     FreshnessColor: FreshnessColor | undefined;
+    /**
+     * <p>Duration in milliseconds for which a given color in the color sequence will down-scroll before taking over full screen.</p>
+     */
     DownscrollDuration: number | undefined;
+    /**
+     * <p>Duration in milliseconds for which a given flat color in the color sequence will be displayed on the full screen.</p>
+     */
     FlatDisplayDuration: number | undefined;
 }
 /**
  * @public
+ * <p>Contains information regarding if a disconnection event took place
+ *       during the Face Liveness session. Disconnection events may indicate processing is complete at the server side.</p>
  */
 export interface DisconnectionEvent {
+    /**
+     * <p>The timestamp that a disconnection event took place at.</p>
+     */
     TimestampMillis: number | undefined;
 }
 /**
@@ -133,24 +276,52 @@ export declare const LightChallengeType: {
 export type LightChallengeType = (typeof LightChallengeType)[keyof typeof LightChallengeType];
 /**
  * @public
+ * <p>Oval parameters need for oval display to complete oval match challenge.</p>
  */
 export interface OvalParameters {
+    /**
+     * <p>Width of the oval</p>
+     */
     Width: number | undefined;
+    /**
+     * <p>Height of the oval</p>
+     */
     Height: number | undefined;
+    /**
+     * <p>X-axis co-ordinate of  for center of oval</p>
+     */
     CenterX: number | undefined;
+    /**
+     * <p>Y-axis co-ordinate of  for center of oval</p>
+     */
     CenterY: number | undefined;
 }
 /**
  * @public
+ * <p>Contains information regarding the <code>OvalParameters</code> and
+ *         <code>LightChallengeType</code> for a challenge.</p>
  */
 export interface FaceMovementAndLightServerChallenge {
+    /**
+     * <p>The parameters needed for an oval to display and to complete oval match challenge.</p>
+     */
     OvalParameters: OvalParameters | undefined;
+    /**
+     * <p>Information on the type of colored light challenge.</p>
+     */
     LightChallengeType: LightChallengeType | string | undefined;
+    /**
+     * <p>Configurations for attributes of the Face Liveness movement and light challenges.</p>
+     */
     ChallengeConfig: ChallengeConfig | undefined;
+    /**
+     * <p>Used to generate a list of color sequences to be displayed on a user's screen.</p>
+     */
     ColorSequences: ColorSequence[] | undefined;
 }
 /**
  * @public
+ * <p>Unexpected error during processing of request.</p>
  */
 export declare class InternalServerException extends __BaseException {
     readonly name: "InternalServerException";
@@ -164,24 +335,38 @@ export declare class InternalServerException extends __BaseException {
 }
 /**
  * @public
+ * <p>Contains the video chunk blob.</p>
  */
 export interface VideoEvent {
+    /**
+     * <p>The video chunk for a video event.</p>
+     */
     VideoChunk?: Uint8Array;
+    /**
+     * <p>Milisecond timestamp for a video chunk in a video event.</p>
+     */
     TimestampMillis?: number;
 }
 /**
  * @public
+ * <p>Contains information regarding video events and client session details for a Face Liveness verification request stream.</p>
  */
 export type LivenessRequestStream = LivenessRequestStream.ClientSessionInformationEventMember | LivenessRequestStream.VideoEventMember | LivenessRequestStream.$UnknownMember;
 /**
  * @public
  */
 export declare namespace LivenessRequestStream {
+    /**
+     * <p>Contains video events for a Face Liveness request stream.</p>
+     */
     interface VideoEventMember {
         VideoEvent: VideoEvent;
         ClientSessionInformationEvent?: never;
         $unknown?: never;
     }
+    /**
+     * <p>Information event for the client session for a given Face Liveness request stream.</p>
+     */
     interface ClientSessionInformationEventMember {
         VideoEvent?: never;
         ClientSessionInformationEvent: ClientSessionInformationEvent;
@@ -201,12 +386,16 @@ export declare namespace LivenessRequestStream {
 }
 /**
  * @public
+ * <p>Information on the challenge sent by the server.</p>
  */
 export type ServerChallenge = ServerChallenge.FaceMovementAndLightChallengeMember | ServerChallenge.$UnknownMember;
 /**
  * @public
  */
 export declare namespace ServerChallenge {
+    /**
+     * <p>Paramteters and configuration information for the face movement and light sequence challenges.</p>
+     */
     interface FaceMovementAndLightChallengeMember {
         FaceMovementAndLightChallenge: FaceMovementAndLightServerChallenge;
         $unknown?: never;
@@ -223,18 +412,27 @@ export declare namespace ServerChallenge {
 }
 /**
  * @public
+ * <p>Information required for the streaming session.</p>
  */
 export interface SessionInformation {
+    /**
+     * <p>Object containing information of Face Liveness challenge to be performed by the client. The information is used to construct the challenges at the client's SDK.</p>
+     */
     Challenge: ServerChallenge | undefined;
 }
 /**
  * @public
+ * <p>Event containing session information for the server.</p>
  */
 export interface ServerSessionInformationEvent {
+    /**
+     * <p>Contains the session information sent by the server..</p>
+     */
     SessionInformation: SessionInformation | undefined;
 }
 /**
  * @public
+ * <p>Occurs when a request would cause a service quota to be exceeded.</p>
  */
 export declare class ServiceQuotaExceededException extends __BaseException {
     readonly name: "ServiceQuotaExceededException";
@@ -248,6 +446,7 @@ export declare class ServiceQuotaExceededException extends __BaseException {
 }
 /**
  * @public
+ * <p>Service-wide throttling to recover from an operational event or service is not able to scale.</p>
  */
 export declare class ServiceUnavailableException extends __BaseException {
     readonly name: "ServiceUnavailableException";
@@ -261,6 +460,8 @@ export declare class ServiceUnavailableException extends __BaseException {
 }
 /**
  * @public
+ * <p>A request was denied due to request throttling. Occurs when too many requests were made by a user
+ *        (exceeding their service quota), the service isn't able to scale, or a service-wide throttling was done to recover from an operational event.</p>
  */
 export declare class ThrottlingException extends __BaseException {
     readonly name: "ThrottlingException";
@@ -274,6 +475,11 @@ export declare class ThrottlingException extends __BaseException {
 }
 /**
  * @public
+ * <p>The input fails to satisfy the constraints specified by the service. Potential reasons
+ *       inlcude: video quality or size is invalid, video container format not supported, video does
+ *       not have enough information - no person detected in video, request couldn't be parsed or is
+ *       invalid, session has expired or is invalid, S3 bucket is invalid/in another AWS region, KMS
+ *       Key is invalid.</p>
  */
 export declare class ValidationException extends __BaseException {
     readonly name: "ValidationException";
@@ -287,12 +493,16 @@ export declare class ValidationException extends __BaseException {
 }
 /**
  * @public
+ * <p>Contains information event details and exception information for a Face Liveness verification response stream.</p>
  */
 export type LivenessResponseStream = LivenessResponseStream.DisconnectionEventMember | LivenessResponseStream.InternalServerExceptionMember | LivenessResponseStream.ServerSessionInformationEventMember | LivenessResponseStream.ServiceQuotaExceededExceptionMember | LivenessResponseStream.ServiceUnavailableExceptionMember | LivenessResponseStream.ThrottlingExceptionMember | LivenessResponseStream.ValidationExceptionMember | LivenessResponseStream.$UnknownMember;
 /**
  * @public
  */
 export declare namespace LivenessResponseStream {
+    /**
+     * <p>Details for a server session information event.</p>
+     */
     interface ServerSessionInformationEventMember {
         ServerSessionInformationEvent: ServerSessionInformationEvent;
         DisconnectionEvent?: never;
@@ -303,6 +513,9 @@ export declare namespace LivenessResponseStream {
         ServiceUnavailableException?: never;
         $unknown?: never;
     }
+    /**
+     * <p>Notification that disconnection event has occurred to a Face Liveness session.</p>
+     */
     interface DisconnectionEventMember {
         ServerSessionInformationEvent?: never;
         DisconnectionEvent: DisconnectionEvent;
@@ -313,6 +526,9 @@ export declare namespace LivenessResponseStream {
         ServiceUnavailableException?: never;
         $unknown?: never;
     }
+    /**
+     * <p>Notification that a ValidationException occurred during a Face Liveness session.</p>
+     */
     interface ValidationExceptionMember {
         ServerSessionInformationEvent?: never;
         DisconnectionEvent?: never;
@@ -323,6 +539,9 @@ export declare namespace LivenessResponseStream {
         ServiceUnavailableException?: never;
         $unknown?: never;
     }
+    /**
+     * <p>Notification that an InternalServerException occurred during a Face Liveness session.</p>
+     */
     interface InternalServerExceptionMember {
         ServerSessionInformationEvent?: never;
         DisconnectionEvent?: never;
@@ -333,6 +552,9 @@ export declare namespace LivenessResponseStream {
         ServiceUnavailableException?: never;
         $unknown?: never;
     }
+    /**
+     * <p>Notification that a ThrottlingException occurred during a Face Liveness session.</p>
+     */
     interface ThrottlingExceptionMember {
         ServerSessionInformationEvent?: never;
         DisconnectionEvent?: never;
@@ -343,6 +565,9 @@ export declare namespace LivenessResponseStream {
         ServiceUnavailableException?: never;
         $unknown?: never;
     }
+    /**
+     * <p>Notification that a ServiceQuotaExceededException occurred during a Face Liveness session.</p>
+     */
     interface ServiceQuotaExceededExceptionMember {
         ServerSessionInformationEvent?: never;
         DisconnectionEvent?: never;
@@ -353,6 +578,9 @@ export declare namespace LivenessResponseStream {
         ServiceUnavailableException?: never;
         $unknown?: never;
     }
+    /**
+     * <p>Notification that a ServiceUnavailableException occurred during a Face Liveness session.</p>
+     */
     interface ServiceUnavailableExceptionMember {
         ServerSessionInformationEvent?: never;
         DisconnectionEvent?: never;
@@ -387,6 +615,7 @@ export declare namespace LivenessResponseStream {
 }
 /**
  * @public
+ * <p>Occurs when the given <code>sessionId</code> is not found.</p>
  */
 export declare class SessionNotFoundException extends __BaseException {
     readonly name: "SessionNotFoundException";
@@ -402,17 +631,41 @@ export declare class SessionNotFoundException extends __BaseException {
  * @public
  */
 export interface StartFaceLivenessSessionRequest {
+    /**
+     * <p>A unique 128-bit UUID. Used to uniquely identify the session and also acta as an
+     *       idempotency token for all operations associated with the session.</p>
+     */
     SessionId: string | undefined;
+    /**
+     * <p>The width of the video object included in a request to start a Face Liveness
+     *       session.</p>
+     */
     VideoWidth: string | undefined;
+    /**
+     * <p>The height of the video object included in a request to start a Face Liveness
+     *       session.</p>
+     */
     VideoHeight: string | undefined;
-    ChallengeVersions?: string;
+    /**
+     * <p>String containing comma separated list of challenge versions supported by client.</p>
+     */
+    ChallengeVersions: string | undefined;
+    /**
+     * <p>Information regarding the request stream for a Face Liveness session.</p>
+     */
     LivenessRequestStream?: AsyncIterable<LivenessRequestStream>;
 }
 /**
  * @public
  */
 export interface StartFaceLivenessSessionResponse {
+    /**
+     * <p>The ID that identifies a Face Liveness session.</p>
+     */
     SessionId: string | undefined;
+    /**
+     * <p>Information regarding the response stream for a Face Liveness session.</p>
+     */
     LivenessResponseStream?: AsyncIterable<LivenessResponseStream>;
 }
 /**

package/dist-types/protocols/Aws_restJson1.d.ts

@@ -1,5 +1,11 @@
 import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
 import { EventStreamSerdeContext as __EventStreamSerdeContext, SerdeContext as __SerdeContext } from "@aws-sdk/types";
 import { StartFaceLivenessSessionCommandInput, StartFaceLivenessSessionCommandOutput } from "../commands/StartFaceLivenessSessionCommand";
-export declare const serializeAws_restJson1StartFaceLivenessSessionCommand: (input: StartFaceLivenessSessionCommandInput, context: __SerdeContext & __EventStreamSerdeContext) => Promise<__HttpRequest>;
-export declare const deserializeAws_restJson1StartFaceLivenessSessionCommand: (output: __HttpResponse, context: __SerdeContext & __EventStreamSerdeContext) => Promise<StartFaceLivenessSessionCommandOutput>;
+/**
+ * serializeAws_restJson1StartFaceLivenessSessionCommand
+ */
+export declare const se_StartFaceLivenessSessionCommand: (input: StartFaceLivenessSessionCommandInput, context: __SerdeContext & __EventStreamSerdeContext) => Promise<__HttpRequest>;
+/**
+ * deserializeAws_restJson1StartFaceLivenessSessionCommand
+ */
+export declare const de_StartFaceLivenessSessionCommand: (output: __HttpResponse, context: __SerdeContext & __EventStreamSerdeContext) => Promise<StartFaceLivenessSessionCommandOutput>;

package/dist-types/ts3.4/models/models_0.d.ts

@@ -318,7 +318,7 @@ export interface StartFaceLivenessSessionRequest {
   SessionId: string | undefined;
   VideoWidth: string | undefined;
   VideoHeight: string | undefined;
-  ChallengeVersions?: string;
+  ChallengeVersions: string | undefined;
   LivenessRequestStream?: AsyncIterable<LivenessRequestStream>;
 }
 export interface StartFaceLivenessSessionResponse {