@aws-sdk/client-rekognitionstreaming 3.305.0 → 3.308.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,12 +1,14 @@
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectString as __expectString, expectUnion as __expectUnion, limitedParseFloat32 as __limitedParseFloat32, map as __map, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
-import { AccessDeniedException, ClientChallenge, InternalServerException, LivenessRequestStream, ServiceQuotaExceededException, SessionNotFoundException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, ClientChallenge, InternalServerException, LivenessRequestStream, ServiceQuotaExceededException, ServiceUnavailableException, SessionNotFoundException, ThrottlingException, ValidationException, } from "../models/models_0";
 import { RekognitionStreamingServiceException as __BaseException } from "../models/RekognitionStreamingServiceException";
 export const serializeAws_restJson1StartFaceLivenessSessionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
         "x-amz-rekognition-streaming-liveness-session-id": input.SessionId,
-        "x-amz-rekognition-streaming-liveness-client-sdk-version": input.ClientSDKVersion,
+        "x-amz-rekognition-streaming-liveness-video-width": input.VideoWidth,
+        "x-amz-rekognition-streaming-liveness-video-height": input.VideoHeight,
+        "x-amz-rekognition-streaming-liveness-challenge-versions": input.ChallengeVersions,
     });
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/start-face-liveness-session";
     let body;
@@ -23,27 +25,6 @@ export const serializeAws_restJson1StartFaceLivenessSessionCommand = async (inpu
         body,
     });
 };
-export const serializeAws_restJson1StartStreamingLivenessSessionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const headers = map({}, isSerializableHeaderValue, {
-        "x-amz-rekognition-streaming-liveness-session-id": input.SessionId,
-        "x-amz-rekognition-streaming-liveness-client-sdk-version": input.ClientSDKVersion,
-    });
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/start-streaming-liveness-session";
-    let body;
-    if (input.LivenessRequestStream !== undefined) {
-        body = serializeAws_restJson1LivenessRequestStream(input.LivenessRequestStream, context);
-    }
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
-};
 export const deserializeAws_restJson1StartFaceLivenessSessionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1StartFaceLivenessSessionCommandError(output, context);
@@ -72,53 +53,9 @@ const deserializeAws_restJson1StartFaceLivenessSessionCommandError = async (outp
         case "ServiceQuotaExceededException":
         case "com.amazonaws.rekognitionstreaming#ServiceQuotaExceededException":
             throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
-        case "SessionNotFoundException":
-        case "com.amazonaws.rekognitionstreaming#SessionNotFoundException":
-            throw await deserializeAws_restJson1SessionNotFoundExceptionResponse(parsedOutput, context);
-        case "ThrottlingException":
-        case "com.amazonaws.rekognitionstreaming#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
-        case "ValidationException":
-        case "com.amazonaws.rekognitionstreaming#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_restJson1StartStreamingLivenessSessionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartStreamingLivenessSessionCommandError(output, context);
-    }
-    const contents = map({
-        $metadata: deserializeMetadata(output),
-        SessionId: [, output.headers["x-amz-rekognition-streaming-liveness-session-id"]],
-    });
-    const data = output.body;
-    contents.LivenessResponseStream = deserializeAws_restJson1LivenessResponseStream(data, context);
-    return contents;
-};
-const deserializeAws_restJson1StartStreamingLivenessSessionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.rekognitionstreaming#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
-        case "InternalServerException":
-        case "com.amazonaws.rekognitionstreaming#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.rekognitionstreaming#ServiceQuotaExceededException":
-            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.rekognitionstreaming#ServiceUnavailableException":
+            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
         case "SessionNotFoundException":
         case "com.amazonaws.rekognitionstreaming#SessionNotFoundException":
             throw await deserializeAws_restJson1SessionNotFoundExceptionResponse(parsedOutput, context);
@@ -184,6 +121,21 @@ const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (par
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Code != null) {
+        contents.Code = __expectString(data.Code);
+    }
+    if (data.Message != null) {
+        contents.Message = __expectString(data.Message);
+    }
+    const exception = new ServiceUnavailableException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const deserializeAws_restJson1SessionNotFoundExceptionResponse = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -291,6 +243,11 @@ const deserializeAws_restJson1LivenessResponseStream = (output, context) => {
                 ServiceQuotaExceededException: await deserializeAws_restJson1ServiceQuotaExceededException_event(event["ServiceQuotaExceededException"], context),
             };
         }
+        if (event["ServiceUnavailableException"] != null) {
+            return {
+                ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
+            };
+        }
         return { $unknown: output };
     });
 };
@@ -320,6 +277,13 @@ const deserializeAws_restJson1ServiceQuotaExceededException_event = async (outpu
     };
     return deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
 };
+const deserializeAws_restJson1ServiceUnavailableException_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+};
 const deserializeAws_restJson1ThrottlingException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -353,9 +317,6 @@ const serializeAws_restJson1ClientChallenge = (input, context) => {
 const serializeAws_restJson1ClientSessionInformationEvent = (input, context) => {
     return {
         ...(input.Challenge != null && { Challenge: serializeAws_restJson1ClientChallenge(input.Challenge, context) }),
-        ...(input.DeviceInformation != null && {
-            DeviceInformation: serializeAws_restJson1DeviceInformation(input.DeviceInformation, context),
-        }),
     };
 };
 const serializeAws_restJson1ColorComponentList = (input, context) => {
@@ -377,13 +338,6 @@ const serializeAws_restJson1ColorDisplayed = (input, context) => {
         ...(input.SequenceNumber != null && { SequenceNumber: input.SequenceNumber }),
     };
 };
-const serializeAws_restJson1DeviceInformation = (input, context) => {
-    return {
-        ...(input.ClientSDKVersion != null && { ClientSDKVersion: input.ClientSDKVersion }),
-        ...(input.VideoHeight != null && { VideoHeight: __serializeFloat(input.VideoHeight) }),
-        ...(input.VideoWidth != null && { VideoWidth: __serializeFloat(input.VideoWidth) }),
-    };
-};
 const serializeAws_restJson1FaceMovementAndLightClientChallenge = (input, context) => {
     return {
         ...(input.ChallengeId != null && { ChallengeId: input.ChallengeId }),
@@ -392,6 +346,7 @@ const serializeAws_restJson1FaceMovementAndLightClientChallenge = (input, contex
         }),
         ...(input.InitialFace != null && { InitialFace: serializeAws_restJson1InitialFace(input.InitialFace, context) }),
         ...(input.TargetFace != null && { TargetFace: serializeAws_restJson1TargetFace(input.TargetFace, context) }),
+        ...(input.VideoEndTimestamp != null && { VideoEndTimestamp: input.VideoEndTimestamp }),
         ...(input.VideoStartTimestamp != null && { VideoStartTimestamp: input.VideoStartTimestamp }),
     };
 };
@@ -425,6 +380,20 @@ const serializeAws_restJson1VideoEvent = (input, context) => {
         ...(input.VideoChunk != null && { VideoChunk: context.base64Encoder(input.VideoChunk) }),
     };
 };
+const deserializeAws_restJson1ChallengeConfig = (output, context) => {
+    return {
+        BlazeFaceDetectionThreshold: __limitedParseFloat32(output.BlazeFaceDetectionThreshold),
+        FaceDistanceThreshold: __limitedParseFloat32(output.FaceDistanceThreshold),
+        FaceDistanceThresholdMax: __limitedParseFloat32(output.FaceDistanceThresholdMax),
+        FaceDistanceThresholdMin: __limitedParseFloat32(output.FaceDistanceThresholdMin),
+        FaceIouHeightThreshold: __limitedParseFloat32(output.FaceIouHeightThreshold),
+        FaceIouWidthThreshold: __limitedParseFloat32(output.FaceIouWidthThreshold),
+        OvalHeightWidthRatio: __limitedParseFloat32(output.OvalHeightWidthRatio),
+        OvalIouHeightThreshold: __limitedParseFloat32(output.OvalIouHeightThreshold),
+        OvalIouThreshold: __limitedParseFloat32(output.OvalIouThreshold),
+        OvalIouWidthThreshold: __limitedParseFloat32(output.OvalIouWidthThreshold),
+    };
+};
 const deserializeAws_restJson1ColorComponentList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -463,12 +432,15 @@ const deserializeAws_restJson1DisconnectionEvent = (output, context) => {
 };
 const deserializeAws_restJson1FaceMovementAndLightServerChallenge = (output, context) => {
     return {
+        ChallengeConfig: output.ChallengeConfig != null
+            ? deserializeAws_restJson1ChallengeConfig(output.ChallengeConfig, context)
+            : undefined,
         ColorSequences: output.ColorSequences != null
             ? deserializeAws_restJson1ColorSequences(output.ColorSequences, context)
             : undefined,
         LightChallengeType: __expectString(output.LightChallengeType),
-        OvalScaleFactors: output.OvalScaleFactors != null
-            ? deserializeAws_restJson1OvalScaleFactors(output.OvalScaleFactors, context)
+        OvalParameters: output.OvalParameters != null
+            ? deserializeAws_restJson1OvalParameters(output.OvalParameters, context)
             : undefined,
     };
 };
@@ -477,10 +449,11 @@ const deserializeAws_restJson1FreshnessColor = (output, context) => {
         RGB: output.RGB != null ? deserializeAws_restJson1ColorComponentList(output.RGB, context) : undefined,
     };
 };
-const deserializeAws_restJson1OvalScaleFactors = (output, context) => {
+const deserializeAws_restJson1OvalParameters = (output, context) => {
     return {
         CenterX: __limitedParseFloat32(output.CenterX),
         CenterY: __limitedParseFloat32(output.CenterY),
+        Height: __limitedParseFloat32(output.Height),
         Width: __limitedParseFloat32(output.Width),
     };
 };

package/dist-types/RekognitionStreaming.d.ts

@@ -1,21 +1,45 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
 import { StartFaceLivenessSessionCommandInput, StartFaceLivenessSessionCommandOutput } from "./commands/StartFaceLivenessSessionCommand";
-import { StartStreamingLivenessSessionCommandInput, StartStreamingLivenessSessionCommandOutput } from "./commands/StartStreamingLivenessSessionCommand";
 import { RekognitionStreamingClient } from "./RekognitionStreamingClient";
 /**
  * @public
+ * <p>A real-time video processing service based on Rekognition. This section documents the API
+ *       operations for Rekognition Face Liveness.</p>
+ *          <p>
+ *             <b>Amazon Rekognition Face Liveness</b>
+ *          </p>
+ *          <ul>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateFaceLivenessSession.html">CreateFaceLivenessSession</a>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetFaceLivenessSessionResults.html">GetFaceLivenessSessionResults</a>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/rekognition/latest/APIReference/API_rekognitionstreaming_StartFaceLivenessSession.html">StartFaceLivenessSession</a>
+ *                </p>
+ *             </li>
+ *          </ul>
  */
 export declare class RekognitionStreaming extends RekognitionStreamingClient {
     /**
      * @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>
      */
     startFaceLivenessSession(args: StartFaceLivenessSessionCommandInput, options?: __HttpHandlerOptions): Promise<StartFaceLivenessSessionCommandOutput>;
     startFaceLivenessSession(args: StartFaceLivenessSessionCommandInput, cb: (err: any, data?: StartFaceLivenessSessionCommandOutput) => void): void;
     startFaceLivenessSession(args: StartFaceLivenessSessionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartFaceLivenessSessionCommandOutput) => void): void;
-    /**
-     * @public
-     */
-    startStreamingLivenessSession(args: StartStreamingLivenessSessionCommandInput, options?: __HttpHandlerOptions): Promise<StartStreamingLivenessSessionCommandOutput>;
-    startStreamingLivenessSession(args: StartStreamingLivenessSessionCommandInput, cb: (err: any, data?: StartStreamingLivenessSessionCommandOutput) => void): void;
-    startStreamingLivenessSession(args: StartStreamingLivenessSessionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartStreamingLivenessSessionCommandOutput) => void): void;
 }

package/dist-types/RekognitionStreamingClient.d.ts

@@ -11,16 +11,15 @@ import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
 import { Client as __Client, DefaultsMode as __DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
 import { BodyLengthCalculator as __BodyLengthCalculator, ChecksumConstructor as __ChecksumConstructor, Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, EventStreamPayloadHandlerProvider as __EventStreamPayloadHandlerProvider, EventStreamSerdeProvider as __EventStreamSerdeProvider, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
 import { StartFaceLivenessSessionCommandInput, StartFaceLivenessSessionCommandOutput } from "./commands/StartFaceLivenessSessionCommand";
-import { StartStreamingLivenessSessionCommandInput, StartStreamingLivenessSessionCommandOutput } from "./commands/StartStreamingLivenessSessionCommand";
 import { ClientInputEndpointParameters, ClientResolvedEndpointParameters, EndpointParameters } from "./endpoint/EndpointParameters";
 /**
  * @public
  */
-export type ServiceInputTypes = StartFaceLivenessSessionCommandInput | StartStreamingLivenessSessionCommandInput;
+export type ServiceInputTypes = StartFaceLivenessSessionCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = StartFaceLivenessSessionCommandOutput | StartStreamingLivenessSessionCommandOutput;
+export type ServiceOutputTypes = StartFaceLivenessSessionCommandOutput;
 /**
  * @public
  */
@@ -157,6 +156,28 @@ export interface RekognitionStreamingClientResolvedConfig extends RekognitionStr
 }
 /**
  * @public
+ * <p>A real-time video processing service based on Rekognition. This section documents the API
+ *       operations for Rekognition Face Liveness.</p>
+ *          <p>
+ *             <b>Amazon Rekognition Face Liveness</b>
+ *          </p>
+ *          <ul>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateFaceLivenessSession.html">CreateFaceLivenessSession</a>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetFaceLivenessSessionResults.html">GetFaceLivenessSessionResults</a>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/rekognition/latest/APIReference/API_rekognitionstreaming_StartFaceLivenessSession.html">StartFaceLivenessSession</a>
+ *                </p>
+ *             </li>
+ *          </ul>
  */
 export declare class RekognitionStreamingClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, RekognitionStreamingClientResolvedConfig> {
     /**

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

@@ -1,2 +1 @@
 export * from "./StartFaceLivenessSessionCommand";
-export * from "./StartStreamingLivenessSessionCommand";