@aws-sdk/client-rekognition 3.36.0 → 3.39.0

package/dist-types/ts3.4/commands/GetContentModerationCommand.d.ts

@@ -6,58 +6,11 @@ export interface GetContentModerationCommandInput extends GetContentModerationRe
 }
 export interface GetContentModerationCommandOutput extends GetContentModerationResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the inappropriate, unwanted, or offensive content analysis results for a Amazon Rekognition Video analysis started by
- *        <a>StartContentModeration</a>. For a list of moderation labels in Amazon Rekognition, see
- *        <a href="https://docs.aws.amazon.com/rekognition/latest/dg/moderation.html#moderation-api">Using the image and video moderation APIs</a>.</p>
- *
- *          <p>Amazon Rekognition Video inappropriate or offensive content detection in a stored video is an asynchronous operation. You start analysis by calling
- *        <a>StartContentModeration</a> which returns a job identifier (<code>JobId</code>).
- *        When analysis finishes, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service
- *        topic registered in the initial call to <code>StartContentModeration</code>.
- *        To get the results of the content analysis, first check that the status value published to the Amazon SNS
- *        topic is <code>SUCCEEDED</code>. If so, call  <code>GetContentModeration</code> and pass the job identifier
- *        (<code>JobId</code>) from the initial call to <code>StartContentModeration</code>. </p>
- *
- *          <p>For more information, see Working with Stored Videos in the
- *      Amazon Rekognition Devlopers Guide.</p>
- *          <p>
- *             <code>GetContentModeration</code> returns detected inappropriate, unwanted, or offensive content moderation labels,
- *       and the time they are detected, in an array, <code>ModerationLabels</code>, of
- *       <a>ContentModerationDetection</a> objects.
- *      </p>
- *          <p>By default, the moderated labels are returned sorted by time, in milliseconds from the start of the
- *        video. You can also sort them by moderated label by specifying <code>NAME</code> for the <code>SortBy</code>
- *        input parameter. </p>
- *          <p>Since video analysis can return a large number of results, use the <code>MaxResults</code> parameter to limit
- *       the number of labels returned in a single call to <code>GetContentModeration</code>. If there are more results than
- *        specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a
- *        pagination token for getting the next set of results. To get the next page of results, call <code>GetContentModeration</code>
- *        and populate the <code>NextToken</code> request parameter with the value of <code>NextToken</code>
- *        returned from the previous call to <code>GetContentModeration</code>.</p>
- *
- *          <p>For more information, see Content moderation in the Amazon Rekognition Developer Guide.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetContentModerationCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetContentModerationCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetContentModerationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetContentModerationCommandInput} for command's `input` shape.
- * @see {@link GetContentModerationCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetContentModerationCommand extends $Command<GetContentModerationCommandInput, GetContentModerationCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetContentModerationCommandInput;
     constructor(input: GetContentModerationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContentModerationCommandInput, GetContentModerationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetFaceDetectionCommand.d.ts

@@ -6,41 +6,11 @@ export interface GetFaceDetectionCommandInput extends GetFaceDetectionRequest {
 }
 export interface GetFaceDetectionCommandOutput extends GetFaceDetectionResponse, __MetadataBearer {
 }
-/**
- * <p>Gets face detection results for a Amazon Rekognition Video analysis started by <a>StartFaceDetection</a>.</p>
- *          <p>Face detection with Amazon Rekognition Video is an asynchronous operation. You start face detection by calling <a>StartFaceDetection</a>
- *      which returns a job identifier (<code>JobId</code>). When the face detection operation finishes, Amazon Rekognition Video publishes a completion status to
- *      the Amazon Simple Notification Service topic registered in the initial call to <code>StartFaceDetection</code>. To get the results
- *      of the face detection operation, first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
- *      If so, call  <a>GetFaceDetection</a> and pass the job identifier
- *      (<code>JobId</code>) from the initial call to <code>StartFaceDetection</code>.</p>
- *          <p>
- *             <code>GetFaceDetection</code> returns an array of detected faces (<code>Faces</code>) sorted by the time the faces were detected. </p>
- *          <p>Use MaxResults parameter to limit the number of labels returned. If there are more results than
- *    specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a pagination token for getting the next set
- *    of results. To get the next page of results, call <code>GetFaceDetection</code> and populate the <code>NextToken</code> request parameter with the token
- *     value returned from the previous call to <code>GetFaceDetection</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetFaceDetectionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetFaceDetectionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetFaceDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFaceDetectionCommandInput} for command's `input` shape.
- * @see {@link GetFaceDetectionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFaceDetectionCommand extends $Command<GetFaceDetectionCommandInput, GetFaceDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetFaceDetectionCommandInput;
     constructor(input: GetFaceDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFaceDetectionCommandInput, GetFaceDetectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetFaceSearchCommand.d.ts

@@ -6,59 +6,11 @@ export interface GetFaceSearchCommandInput extends GetFaceSearchRequest {
 }
 export interface GetFaceSearchCommandOutput extends GetFaceSearchResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the face search results for Amazon Rekognition Video face search started by
- *       <a>StartFaceSearch</a>. The search returns faces in a collection that match the faces
- *     of persons detected in a video. It also includes the time(s) that faces are matched in the video.</p>
- *          <p>Face search in a video is an asynchronous operation. You start face search by calling
- *       to <a>StartFaceSearch</a> which returns a job identifier (<code>JobId</code>).
- *       When the search operation finishes, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service
- *       topic registered in the initial call to <code>StartFaceSearch</code>.
- *       To get the search results, first check that the status value published to the Amazon SNS
- *       topic is <code>SUCCEEDED</code>. If so, call  <code>GetFaceSearch</code> and pass the job identifier
- *       (<code>JobId</code>) from the initial call to <code>StartFaceSearch</code>.</p>
- *
- *          <p>For more information, see Searching Faces in a Collection in the
- *       Amazon Rekognition Developer Guide.</p>
- *          <p>The search results are retured in an array, <code>Persons</code>, of
- *     <a>PersonMatch</a> objects. Each<code>PersonMatch</code> element contains
- *     details about the matching faces in the input collection, person information (facial attributes,
- *     bounding boxes, and person identifer)
- *     for the matched person, and the time the person was matched in the video.</p>
- *          <note>
- *             <p>
- *                <code>GetFaceSearch</code> only returns the default
- *         facial attributes (<code>BoundingBox</code>, <code>Confidence</code>,
- *         <code>Landmarks</code>, <code>Pose</code>, and <code>Quality</code>). The other facial attributes listed
- *         in the <code>Face</code> object of the following response syntax are not returned. For more information,
- *         see FaceDetail in the Amazon Rekognition Developer Guide. </p>
- *          </note>
- *
- *          <p>By default, the <code>Persons</code> array is sorted by the time, in milliseconds from the
- *     start of the video, persons are matched.
- *     You can also sort by persons by specifying <code>INDEX</code> for the <code>SORTBY</code> input
- *     parameter.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetFaceSearchCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetFaceSearchCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetFaceSearchCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFaceSearchCommandInput} for command's `input` shape.
- * @see {@link GetFaceSearchCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFaceSearchCommand extends $Command<GetFaceSearchCommandInput, GetFaceSearchCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetFaceSearchCommandInput;
     constructor(input: GetFaceSearchCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFaceSearchCommandInput, GetFaceSearchCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetLabelDetectionCommand.d.ts

@@ -6,49 +6,11 @@ export interface GetLabelDetectionCommandInput extends GetLabelDetectionRequest
 }
 export interface GetLabelDetectionCommandOutput extends GetLabelDetectionResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the label detection results of a Amazon Rekognition Video analysis started by <a>StartLabelDetection</a>.  </p>
- *
- *          <p>The label detection operation is started by a call to <a>StartLabelDetection</a>
- *       which returns a job identifier (<code>JobId</code>). When the label detection operation finishes, Amazon Rekognition publishes a completion status to
- *       the Amazon Simple Notification Service topic registered in the initial call to <code>StartlabelDetection</code>. To get the results
- *       of the label detection operation, first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
- *       If so, call  <a>GetLabelDetection</a> and pass the job identifier
- *       (<code>JobId</code>) from the initial call to <code>StartLabelDetection</code>.</p>
- *          <p>
- *             <code>GetLabelDetection</code> returns an array of detected labels (<code>Labels</code>) sorted by the time
- *        the labels were detected. You can also sort by the label name by specifying <code>NAME</code> for the
- *        <code>SortBy</code> input parameter.</p>
- *          <p>The labels returned include the label name, the percentage confidence in the accuracy of the detected label,
- *         and the time the label was detected in the video.</p>
- *          <p>The returned labels also include bounding box information for common objects, a
- *        hierarchical taxonomy of detected labels, and the version of the label model used for detection.</p>
- *
- *          <p>Use MaxResults parameter to limit the number of labels returned. If there are more results than
- *     specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a pagination token for getting the next set
- *     of results. To get the next page of results, call <code>GetlabelDetection</code> and populate the <code>NextToken</code> request parameter with the token
- *      value returned from the previous call to <code>GetLabelDetection</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetLabelDetectionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetLabelDetectionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetLabelDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetLabelDetectionCommandInput} for command's `input` shape.
- * @see {@link GetLabelDetectionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetLabelDetectionCommand extends $Command<GetLabelDetectionCommandInput, GetLabelDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetLabelDetectionCommandInput;
     constructor(input: GetLabelDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLabelDetectionCommandInput, GetLabelDetectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetPersonTrackingCommand.d.ts

@@ -6,58 +6,11 @@ export interface GetPersonTrackingCommandInput extends GetPersonTrackingRequest
 }
 export interface GetPersonTrackingCommandOutput extends GetPersonTrackingResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the path tracking results of a Amazon Rekognition Video analysis started by <a>StartPersonTracking</a>.</p>
- *
- *          <p>The person path tracking operation is started by a call to <code>StartPersonTracking</code>
- *      which returns a job identifier (<code>JobId</code>). When the operation finishes, Amazon Rekognition Video publishes a completion status to
- *      the Amazon Simple Notification Service topic registered in the initial call to <code>StartPersonTracking</code>.</p>
- *          <p>To get the results of the person path tracking operation, first check
- *        that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
- *      If so, call  <a>GetPersonTracking</a> and pass the job identifier
- *      (<code>JobId</code>) from the initial call to <code>StartPersonTracking</code>.</p>
- *          <p>
- *             <code>GetPersonTracking</code> returns an array, <code>Persons</code>, of tracked persons and the time(s) their
- *        paths were tracked in the video. </p>
- *          <note>
- *             <p>
- *                <code>GetPersonTracking</code> only returns the default
- *        facial attributes (<code>BoundingBox</code>, <code>Confidence</code>,
- *        <code>Landmarks</code>, <code>Pose</code>, and <code>Quality</code>). The other facial attributes listed
- *        in the <code>Face</code> object of the following response syntax are not returned. </p>
- *
- *             <p>For more information, see FaceDetail in the Amazon Rekognition Developer Guide.</p>
- *          </note>
- *
- *
- *          <p>By default, the array is sorted by the time(s) a person's path is tracked in the video.
- *       You can sort by tracked persons by specifying <code>INDEX</code> for the <code>SortBy</code> input parameter.</p>
- *
- *          <p>Use the <code>MaxResults</code> parameter to limit the number of items returned. If there are more results than
- *    specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a pagination token for getting the next set
- *    of results. To get the next page of results, call <code>GetPersonTracking</code> and populate the <code>NextToken</code> request parameter with the token
- *     value returned from the previous call to <code>GetPersonTracking</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetPersonTrackingCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetPersonTrackingCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetPersonTrackingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetPersonTrackingCommandInput} for command's `input` shape.
- * @see {@link GetPersonTrackingCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetPersonTrackingCommand extends $Command<GetPersonTrackingCommandInput, GetPersonTrackingCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetPersonTrackingCommandInput;
     constructor(input: GetPersonTrackingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPersonTrackingCommandInput, GetPersonTrackingCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetSegmentDetectionCommand.d.ts

@@ -6,51 +6,11 @@ export interface GetSegmentDetectionCommandInput extends GetSegmentDetectionRequ
 }
 export interface GetSegmentDetectionCommandOutput extends GetSegmentDetectionResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the segment detection results of a Amazon Rekognition Video analysis started by <a>StartSegmentDetection</a>.</p>
- *          <p>Segment detection with Amazon Rekognition Video is an asynchronous operation. You start segment detection by
- *       calling <a>StartSegmentDetection</a> which returns a job identifier (<code>JobId</code>).
- *       When the segment detection operation finishes, Amazon Rekognition publishes a completion status to the Amazon Simple Notification Service
- *       topic registered in the initial call to <code>StartSegmentDetection</code>. To get the results
- *       of the segment detection operation, first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
- *       if so, call <code>GetSegmentDetection</code> and pass the job identifier (<code>JobId</code>) from the initial call
- *       of <code>StartSegmentDetection</code>.</p>
- *          <p>
- *             <code>GetSegmentDetection</code> returns detected segments in an array (<code>Segments</code>)
- *       of <a>SegmentDetection</a> objects. <code>Segments</code> is sorted by the segment types
- *       specified in the <code>SegmentTypes</code> input parameter of <code>StartSegmentDetection</code>.
- *     Each element of the array includes the detected segment, the precentage confidence in the acuracy
- *       of the detected segment, the type of the segment, and the frame in which the segment was detected.</p>
- *          <p>Use <code>SelectedSegmentTypes</code> to find out the type of segment detection requested in the
- *     call to <code>StartSegmentDetection</code>.</p>
- *          <p>Use the <code>MaxResults</code> parameter to limit the number of segment detections returned. If there are more results than
- *       specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains
- *       a pagination token for getting the next set of results. To get the next page of results, call <code>GetSegmentDetection</code>
- *       and populate the <code>NextToken</code> request parameter with the token value returned from the previous
- *       call to <code>GetSegmentDetection</code>.</p>
- *
- *          <p>For more information, see Detecting Video Segments in Stored Video in the Amazon Rekognition Developer Guide.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetSegmentDetectionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetSegmentDetectionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetSegmentDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSegmentDetectionCommandInput} for command's `input` shape.
- * @see {@link GetSegmentDetectionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSegmentDetectionCommand extends $Command<GetSegmentDetectionCommandInput, GetSegmentDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetSegmentDetectionCommandInput;
     constructor(input: GetSegmentDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSegmentDetectionCommandInput, GetSegmentDetectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetTextDetectionCommand.d.ts

@@ -6,47 +6,11 @@ export interface GetTextDetectionCommandInput extends GetTextDetectionRequest {
 }
 export interface GetTextDetectionCommandOutput extends GetTextDetectionResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the text detection results of a Amazon Rekognition Video analysis started by <a>StartTextDetection</a>.</p>
- *          <p>Text detection with Amazon Rekognition Video is an asynchronous operation. You start text detection by
- *      calling <a>StartTextDetection</a> which returns a job identifier (<code>JobId</code>)
- *      When the text detection operation finishes, Amazon Rekognition publishes a completion status to the Amazon Simple Notification Service
- *      topic registered in the initial call to <code>StartTextDetection</code>. To get the results
- *      of the text detection operation, first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
- *      if so, call <code>GetTextDetection</code> and pass the job identifier (<code>JobId</code>) from the initial call
- *      of <code>StartLabelDetection</code>.</p>
- *          <p>
- *             <code>GetTextDetection</code> returns an array of detected text (<code>TextDetections</code>) sorted by
- *        the time the text was detected, up to 50 words per frame of video.</p>
- *          <p>Each element of the array includes the detected text, the precentage confidence in the acuracy
- *        of the detected text, the time the text was detected, bounding box information for where the text
- *        was located, and unique identifiers for words and their lines.</p>
- *          <p>Use MaxResults parameter to limit the number of text detections returned. If there are more results than
- *      specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains
- *      a pagination token for getting the next set of results. To get the next page of results, call <code>GetTextDetection</code>
- *      and populate the <code>NextToken</code> request parameter with the token value returned from the previous
- *      call to <code>GetTextDetection</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetTextDetectionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetTextDetectionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetTextDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetTextDetectionCommandInput} for command's `input` shape.
- * @see {@link GetTextDetectionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetTextDetectionCommand extends $Command<GetTextDetectionCommandInput, GetTextDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetTextDetectionCommandInput;
     constructor(input: GetTextDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTextDetectionCommandInput, GetTextDetectionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/IndexFacesCommand.d.ts

@@ -6,128 +6,11 @@ export interface IndexFacesCommandInput extends IndexFacesRequest {
 }
 export interface IndexFacesCommandOutput extends IndexFacesResponse, __MetadataBearer {
 }
-/**
- * <p>Detects faces in the input image and adds them to the specified collection. </p>
- *          <p>Amazon Rekognition doesn't save the actual faces that are detected. Instead, the underlying
- *       detection algorithm first detects the faces in the input image. For each face, the algorithm
- *       extracts facial features into a feature vector, and stores it in the backend database.
- *       Amazon Rekognition uses feature vectors when it performs face match and search operations using the
- *         <a>SearchFaces</a> and <a>SearchFacesByImage</a>
- *       operations.</p>
- *
- *          <p>For more information, see Adding Faces to a Collection in the Amazon Rekognition
- *       Developer Guide.</p>
- *          <p>To get the number of faces in a collection, call <a>DescribeCollection</a>. </p>
- *
- *          <p>If you're using version 1.0 of the face detection model, <code>IndexFaces</code>
- *       indexes the 15 largest faces in the input image. Later versions of the face detection model
- *       index the 100 largest faces in the input image. </p>
- *          <p>If you're using version 4 or later of the face model, image orientation information
- *      is not returned in the <code>OrientationCorrection</code> field. </p>
- *          <p>To determine which version of the model you're using, call <a>DescribeCollection</a>
- *       and supply the collection ID. You can also get the model version from the value of <code>FaceModelVersion</code> in the response
- *       from <code>IndexFaces</code>
- *          </p>
- *
- *          <p>For more information, see Model Versioning in the Amazon Rekognition Developer
- *       Guide.</p>
- *          <p>If you provide the optional <code>ExternalImageId</code> for the input image you
- *       provided, Amazon Rekognition associates this ID with all faces that it detects. When you call the <a>ListFaces</a> operation, the response returns the external ID. You can use this
- *       external image ID to create a client-side index to associate the faces with each image. You
- *       can then use the index to find all faces in an image.</p>
- *          <p>You can specify the maximum number of faces to index with the <code>MaxFaces</code> input
- *       parameter. This is useful when you want to index the largest faces in an image and don't want to index
- *       smaller faces, such as those belonging to people standing in the background.</p>
- *          <p>The <code>QualityFilter</code> input parameter allows you to filter out detected faces
- *       that don’t meet a required quality bar. The quality bar is based on a
- *       variety of common use cases. By default, <code>IndexFaces</code> chooses the quality bar that's
- *       used to filter faces.  You can also explicitly choose
- *       the quality bar. Use <code>QualityFilter</code>, to set the quality bar
- *       by specifying <code>LOW</code>, <code>MEDIUM</code>, or <code>HIGH</code>.
- *       If you do not want to filter detected faces, specify <code>NONE</code>. </p>
- *          <note>
- *             <p>To use quality filtering, you need a collection associated with version 3 of the
- *     face model or higher. To get the version of the face model associated with a collection, call
- *       <a>DescribeCollection</a>. </p>
- *          </note>
- *          <p>Information about faces detected in an image, but not indexed, is returned in an array of
- *       <a>UnindexedFace</a> objects, <code>UnindexedFaces</code>. Faces aren't
- *       indexed for reasons such as:</p>
- *          <ul>
- *             <li>
- *                <p>The number of faces detected exceeds the value of the <code>MaxFaces</code> request
- *           parameter.</p>
- *             </li>
- *             <li>
- *                <p>The face is too small compared to the image dimensions.</p>
- *             </li>
- *             <li>
- *                <p>The face is too blurry.</p>
- *             </li>
- *             <li>
- *                <p>The image is too dark.</p>
- *             </li>
- *             <li>
- *                <p>The face has an extreme pose.</p>
- *             </li>
- *             <li>
- *                <p>The face doesn’t have enough detail to be suitable for face search.</p>
- *             </li>
- *          </ul>
- *          <p>In response, the <code>IndexFaces</code> operation returns an array of metadata for
- *       all detected faces, <code>FaceRecords</code>. This includes: </p>
- *          <ul>
- *             <li>
- *                <p>The bounding box, <code>BoundingBox</code>, of the detected face. </p>
- *             </li>
- *             <li>
- *                <p>A confidence value, <code>Confidence</code>, which indicates the confidence that the
- *           bounding box contains a face.</p>
- *             </li>
- *             <li>
- *                <p>A face ID, <code>FaceId</code>, assigned by the service for each face that's detected
- *           and stored.</p>
- *             </li>
- *             <li>
- *                <p>An image ID, <code>ImageId</code>, assigned by the service for the input image.</p>
- *             </li>
- *          </ul>
- *          <p>If you request all facial attributes (by using the <code>detectionAttributes</code>
- *       parameter), Amazon Rekognition returns detailed facial attributes, such as facial landmarks (for
- *       example, location of eye and mouth) and other facial attributes. If you provide
- *       the same image, specify the same collection, and use the same external ID in the
- *         <code>IndexFaces</code> operation, Amazon Rekognition doesn't save duplicate face metadata.</p>
- *
- *
- *          <p></p>
- *
- *
- *          <p>The input image is passed either as base64-encoded image bytes, or as a reference to an
- *       image in an Amazon S3 bucket. If you use the AWS CLI to call Amazon Rekognition operations,
- *       passing image bytes isn't supported. The image must be formatted as a PNG or JPEG file. </p>
- *          <p>This operation requires permissions to perform the <code>rekognition:IndexFaces</code>
- *       action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, IndexFacesCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, IndexFacesCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new IndexFacesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link IndexFacesCommandInput} for command's `input` shape.
- * @see {@link IndexFacesCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class IndexFacesCommand extends $Command<IndexFacesCommandInput, IndexFacesCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: IndexFacesCommandInput;
     constructor(input: IndexFacesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<IndexFacesCommandInput, IndexFacesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListCollectionsCommand.d.ts

@@ -6,34 +6,11 @@ export interface ListCollectionsCommandInput extends ListCollectionsRequest {
 }
 export interface ListCollectionsCommandOutput extends ListCollectionsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns list of collection IDs in your account.
- *     If the result is truncated, the response also provides a <code>NextToken</code>
- *     that you can use in the subsequent request to fetch the next set of collection IDs.</p>
- *
- *          <p>For an example, see Listing Collections in the Amazon Rekognition Developer Guide.</p>
- *          <p>This operation requires permissions to perform the <code>rekognition:ListCollections</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, ListCollectionsCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, ListCollectionsCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new ListCollectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListCollectionsCommandInput} for command's `input` shape.
- * @see {@link ListCollectionsCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListCollectionsCommand extends $Command<ListCollectionsCommandInput, ListCollectionsCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: ListCollectionsCommandInput;
     constructor(input: ListCollectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCollectionsCommandInput, ListCollectionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListFacesCommand.d.ts

@@ -6,36 +6,11 @@ export interface ListFacesCommandInput extends ListFacesRequest {
 }
 export interface ListFacesCommandOutput extends ListFacesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns metadata for faces in the specified collection.
- *       This metadata includes information such as the bounding box coordinates, the confidence
- *       (that the bounding box contains a face), and face ID. For an example, see Listing Faces in a Collection
- *       in the Amazon Rekognition Developer Guide.</p>
- *
- *
- *          <p>This operation requires permissions to perform the
- *       <code>rekognition:ListFaces</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, ListFacesCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, ListFacesCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new ListFacesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFacesCommandInput} for command's `input` shape.
- * @see {@link ListFacesCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFacesCommand extends $Command<ListFacesCommandInput, ListFacesCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: ListFacesCommandInput;
     constructor(input: ListFacesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFacesCommandInput, ListFacesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListStreamProcessorsCommand.d.ts

@@ -6,29 +6,11 @@ export interface ListStreamProcessorsCommandInput extends ListStreamProcessorsRe
 }
 export interface ListStreamProcessorsCommandOutput extends ListStreamProcessorsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of stream processors that you have created with <a>CreateStreamProcessor</a>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, ListStreamProcessorsCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, ListStreamProcessorsCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new ListStreamProcessorsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListStreamProcessorsCommandInput} for command's `input` shape.
- * @see {@link ListStreamProcessorsCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListStreamProcessorsCommand extends $Command<ListStreamProcessorsCommandInput, ListStreamProcessorsCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: ListStreamProcessorsCommandInput;
     constructor(input: ListStreamProcessorsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStreamProcessorsCommandInput, ListStreamProcessorsCommandOutput>;
     private serialize;
     private deserialize;