@aws-sdk/client-rekognition 3.36.0 → 3.39.0

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

@@ -6,33 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>
- *       Returns a list of tags in an Amazon Rekognition collection, stream processor, or Custom Labels model.
- *     </p>
- *          <p>This operation requires permissions to perform the
- *       <code>rekognition:ListTagsForResource</code> action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, ListTagsForResourceCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, ListTagsForResourceCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,59 +6,11 @@ export interface RecognizeCelebritiesCommandInput extends RecognizeCelebritiesRe
 }
 export interface RecognizeCelebritiesCommandOutput extends RecognizeCelebritiesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns an array of celebrities recognized in the input image.  For more information, see Recognizing Celebrities
- *     in the Amazon Rekognition Developer Guide. </p>
- *          <p>
- *             <code>RecognizeCelebrities</code> returns the 64 largest faces in the image. It lists
- *       recognized celebrities in the <code>CelebrityFaces</code> array and unrecognized faces in the
- *         <code>UnrecognizedFaces</code> array. <code>RecognizeCelebrities</code> doesn't return
- *       celebrities whose faces aren't among the largest 64 faces in the image.</p>
- *
- *          <p>For each celebrity recognized, <code>RecognizeCelebrities</code> returns a
- *         <code>Celebrity</code> object. The <code>Celebrity</code> object contains the celebrity
- *       name, ID, URL links to additional information, match confidence, and a
- *         <code>ComparedFace</code> object that you can use to locate the celebrity's face on the
- *       image.</p>
- *          <p>Amazon Rekognition doesn't retain information about which images a celebrity has been recognized
- *       in. Your application must store this information and use the <code>Celebrity</code> ID
- *       property as a unique identifier for the celebrity. If you don't store the celebrity name or
- *       additional information URLs returned by <code>RecognizeCelebrities</code>, you will need the
- *       ID to identify the celebrity in a call to the <a>GetCelebrityInfo</a>
- *       operation.</p>
- *          <p>You pass the input image 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 is not
- *       supported. The image must be either a PNG or JPEG formatted file. </p>
- *
- *
- *
- *
- *          <p>For an example, see Recognizing Celebrities in an Image in the Amazon Rekognition Developer Guide.</p>
- *          <p>This operation requires permissions to perform the
- *         <code>rekognition:RecognizeCelebrities</code> operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, RecognizeCelebritiesCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, RecognizeCelebritiesCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new RecognizeCelebritiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RecognizeCelebritiesCommandInput} for command's `input` shape.
- * @see {@link RecognizeCelebritiesCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RecognizeCelebritiesCommand extends $Command<RecognizeCelebritiesCommandInput, RecognizeCelebritiesCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: RecognizeCelebritiesCommandInput;
     constructor(input: RecognizeCelebritiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RecognizeCelebritiesCommandInput, RecognizeCelebritiesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,75 +6,11 @@ export interface SearchFacesByImageCommandInput extends SearchFacesByImageReques
 }
 export interface SearchFacesByImageCommandOutput extends SearchFacesByImageResponse, __MetadataBearer {
 }
-/**
- * <p>For a given input image, first detects the largest face in the image, and then searches
- *       the specified collection for matching faces. The operation compares the features of the input
- *       face with faces in the specified collection. </p>
- *          <note>
- *             <p>To search for all faces in an input image, you might first call the <a>IndexFaces</a> operation, and then use the face IDs returned in subsequent
- *         calls to the <a>SearchFaces</a> operation. </p>
- *             <p> You can also call the <code>DetectFaces</code> operation and use the bounding boxes
- *         in the response to make face crops, which then you can pass in to the
- *           <code>SearchFacesByImage</code> operation. </p>
- *          </note>
- *
- *          <p>You pass the input image 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 is not
- *       supported. The image must be either a PNG or JPEG formatted file. </p>
- *          <p>
- *       The response returns an array of faces that match, ordered by similarity score with the
- *       highest similarity first. More specifically, it is an
- *       array of metadata for each face match found. Along with the metadata, the response also
- *       includes a <code>similarity</code> indicating how similar the face is
- *       to the input face.
- *
- *       In the response, the operation also returns the bounding
- *       box (and a confidence level that the bounding box contains a face) of the face that Amazon Rekognition
- *       used for the input image.
- *     </p>
- *          <p>If no faces are detected in the input image, <code>SearchFacesByImage</code> returns an
- *       <code>InvalidParameterException</code> error. </p>
- *
- *          <p>For an example, Searching for a Face Using an Image in the Amazon Rekognition Developer Guide.</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.
- *       Use <code>QualityFilter</code> to set the quality bar for
- *       filtering 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>. The default
- *       value is <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>This operation requires permissions to perform the <code>rekognition:SearchFacesByImage</code>
- *       action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, SearchFacesByImageCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, SearchFacesByImageCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new SearchFacesByImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SearchFacesByImageCommandInput} for command's `input` shape.
- * @see {@link SearchFacesByImageCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SearchFacesByImageCommand extends $Command<SearchFacesByImageCommandInput, SearchFacesByImageCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: SearchFacesByImageCommandInput;
     constructor(input: SearchFacesByImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchFacesByImageCommandInput, SearchFacesByImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,49 +6,11 @@ export interface SearchFacesCommandInput extends SearchFacesRequest {
 }
 export interface SearchFacesCommandOutput extends SearchFacesResponse, __MetadataBearer {
 }
-/**
- * <p>For a given input face ID, searches for matching faces in the collection the face
- *       belongs to. You get a face ID when you add a face to the collection using the <a>IndexFaces</a> operation. The operation compares the features of the input face with
- *       faces in the specified collection. </p>
- *          <note>
- *             <p>You can also search faces without indexing faces by using the
- *           <code>SearchFacesByImage</code> operation.</p>
- *          </note>
- *
- *          <p>
- *      The operation response returns
- *       an array of faces that match, ordered by similarity score with the highest
- *       similarity first. More specifically, it is an
- *       array of metadata for each face match that is found. Along with the metadata, the response also
- *       includes a <code>confidence</code> value for each face match, indicating the confidence
- *       that the specific face matches the input face.
- *     </p>
- *
- *          <p>For an example, see Searching for a Face Using Its Face ID in the Amazon Rekognition Developer Guide.</p>
- *
- *          <p>This operation requires permissions to perform the <code>rekognition:SearchFaces</code>
- *       action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, SearchFacesCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, SearchFacesCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new SearchFacesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SearchFacesCommandInput} for command's `input` shape.
- * @see {@link SearchFacesCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SearchFacesCommand extends $Command<SearchFacesCommandInput, SearchFacesCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: SearchFacesCommandInput;
     constructor(input: SearchFacesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchFacesCommandInput, SearchFacesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface StartCelebrityRecognitionCommandInput extends StartCelebrityRec
 }
 export interface StartCelebrityRecognitionCommandOutput extends StartCelebrityRecognitionResponse, __MetadataBearer {
 }
-/**
- * <p>Starts asynchronous recognition of celebrities in a stored video.</p>
- *          <p>Amazon Rekognition Video can detect celebrities in a video must be stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
- *       and the filename of the video.
- *       <code>StartCelebrityRecognition</code>
- *       returns a job identifier (<code>JobId</code>) which you use to get the results of the analysis.
- *       When celebrity recognition analysis is finished, Amazon Rekognition Video publishes a completion status
- *       to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>.
- *       To get the results of the celebrity recognition analysis, first check that the status value published to the Amazon SNS
- *       topic is <code>SUCCEEDED</code>. If so, call  <a>GetCelebrityRecognition</a> and pass the job identifier
- *       (<code>JobId</code>) from the initial call to <code>StartCelebrityRecognition</code>. </p>
- *
- *          <p>For more information, see Recognizing Celebrities 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, StartCelebrityRecognitionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartCelebrityRecognitionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartCelebrityRecognitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartCelebrityRecognitionCommandInput} for command's `input` shape.
- * @see {@link StartCelebrityRecognitionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartCelebrityRecognitionCommand extends $Command<StartCelebrityRecognitionCommandInput, StartCelebrityRecognitionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartCelebrityRecognitionCommandInput;
     constructor(input: StartCelebrityRecognitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartCelebrityRecognitionCommandInput, StartCelebrityRecognitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface StartContentModerationCommandInput extends StartContentModerati
 }
 export interface StartContentModerationCommandOutput extends StartContentModerationResponse, __MetadataBearer {
 }
-/**
- * <p> Starts asynchronous detection of inappropriate, unwanted, or offensive content in a stored video. 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 can moderate content in a video stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
- *       and the filename of the video. <code>StartContentModeration</code>
- *         returns a job identifier (<code>JobId</code>) which you use to get the results of the analysis.
- *         When content analysis is finished, Amazon Rekognition Video publishes a completion status
- *         to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>.</p>
- *         <p>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 <a>GetContentModeration</a> and pass the job identifier
- *         (<code>JobId</code>) from the initial call to <code>StartContentModeration</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, StartContentModerationCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartContentModerationCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartContentModerationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartContentModerationCommandInput} for command's `input` shape.
- * @see {@link StartContentModerationCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartContentModerationCommand extends $Command<StartContentModerationCommandInput, StartContentModerationCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartContentModerationCommandInput;
     constructor(input: StartContentModerationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartContentModerationCommandInput, StartContentModerationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface StartFaceDetectionCommandInput extends StartFaceDetectionReques
 }
 export interface StartFaceDetectionCommandOutput extends StartFaceDetectionResponse, __MetadataBearer {
 }
-/**
- * <p>Starts asynchronous detection of faces in a stored video.</p>
- *          <p>Amazon Rekognition Video can detect faces in a video stored in an Amazon S3 bucket.
- *        Use <a>Video</a> to specify the bucket name and the filename of the video.
- *        <code>StartFaceDetection</code> returns a job identifier (<code>JobId</code>) that you
- *        use to get the results of the operation.
- *        When face detection is finished, Amazon Rekognition Video publishes a completion status
- *        to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</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>For more information, see Detecting Faces in a 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, StartFaceDetectionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartFaceDetectionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartFaceDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartFaceDetectionCommandInput} for command's `input` shape.
- * @see {@link StartFaceDetectionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartFaceDetectionCommand extends $Command<StartFaceDetectionCommandInput, StartFaceDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartFaceDetectionCommandInput;
     constructor(input: StartFaceDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartFaceDetectionCommandInput, StartFaceDetectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface StartFaceSearchCommandInput extends StartFaceSearchRequest {
 }
 export interface StartFaceSearchCommandOutput extends StartFaceSearchResponse, __MetadataBearer {
 }
-/**
- * <p>Starts the asynchronous search for faces in a collection that match the faces of persons detected in a stored video.</p>
- *          <p>The video must be stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
- *       and the filename of the video. <code>StartFaceSearch</code>
- *       returns a job identifier (<code>JobId</code>) which you use to get the search results once the search has completed.
- *       When searching is finished, Amazon Rekognition Video publishes a completion status
- *       to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</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 <a>GetFaceSearch</a> and pass the job identifier
- *       (<code>JobId</code>) from the initial call to <code>StartFaceSearch</code>. For more information, see
- *       <a>procedure-person-search-videos</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, StartFaceSearchCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartFaceSearchCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartFaceSearchCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartFaceSearchCommandInput} for command's `input` shape.
- * @see {@link StartFaceSearchCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartFaceSearchCommand extends $Command<StartFaceSearchCommandInput, StartFaceSearchCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartFaceSearchCommandInput;
     constructor(input: StartFaceSearchCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartFaceSearchCommandInput, StartFaceSearchCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,43 +6,11 @@ export interface StartLabelDetectionCommandInput extends StartLabelDetectionRequ
 }
 export interface StartLabelDetectionCommandOutput extends StartLabelDetectionResponse, __MetadataBearer {
 }
-/**
- * <p>Starts asynchronous detection of labels in a stored video.</p>
- *          <p>Amazon Rekognition Video can detect labels in a video. Labels are instances of real-world entities.
- *        This includes objects like flower, tree, and table; events like
- *        wedding, graduation, and birthday party; concepts like landscape, evening, and nature; and activities
- *        like a person getting out of a car or a person skiing.</p>
- *
- *          <p>The video must be stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
- *        and the filename of the video.
- *         <code>StartLabelDetection</code> returns a job identifier (<code>JobId</code>) which you use to get the
- *        results of the operation. When label detection is finished, Amazon Rekognition Video publishes a completion status
- *         to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>.</p>
- *          <p>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></p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, StartLabelDetectionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartLabelDetectionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartLabelDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartLabelDetectionCommandInput} for command's `input` shape.
- * @see {@link StartLabelDetectionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartLabelDetectionCommand extends $Command<StartLabelDetectionCommandInput, StartLabelDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartLabelDetectionCommandInput;
     constructor(input: StartLabelDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartLabelDetectionCommandInput, StartLabelDetectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface StartPersonTrackingCommandInput extends StartPersonTrackingRequ
 }
 export interface StartPersonTrackingCommandOutput extends StartPersonTrackingResponse, __MetadataBearer {
 }
-/**
- * <p>Starts the asynchronous tracking of a person's path in a stored video.</p>
- *          <p>Amazon Rekognition Video can track the path of people in a video stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
- *        and the filename of the video. <code>StartPersonTracking</code>
- *        returns a job identifier (<code>JobId</code>) which you use to get the results of the operation.
- *        When label detection is finished, Amazon Rekognition publishes a completion status
- *        to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>. </p>
- *          <p>To get the results of the person detection 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, StartPersonTrackingCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartPersonTrackingCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartPersonTrackingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartPersonTrackingCommandInput} for command's `input` shape.
- * @see {@link StartPersonTrackingCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartPersonTrackingCommand extends $Command<StartPersonTrackingCommandInput, StartPersonTrackingCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartPersonTrackingCommandInput;
     constructor(input: StartPersonTrackingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartPersonTrackingCommandInput, StartPersonTrackingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface StartProjectVersionCommandInput extends StartProjectVersionRequ
 }
 export interface StartProjectVersionCommandOutput extends StartProjectVersionResponse, __MetadataBearer {
 }
-/**
- * <p>Starts the running of the version of a model. Starting a model takes a while
- *       to complete. To check the current state of the model, use <a>DescribeProjectVersions</a>.</p>
- *          <p>Once the model is running, you can detect custom labels in new images by calling
- *          <a>DetectCustomLabels</a>.</p>
- *          <note>
- *             <p>You are charged for the amount of time that the model is running. To stop a running
- *       model, call <a>StopProjectVersion</a>.</p>
- *          </note>
- *          <p>This operation requires permissions to perform the
- *          <code>rekognition:StartProjectVersion</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, StartProjectVersionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartProjectVersionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartProjectVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartProjectVersionCommandInput} for command's `input` shape.
- * @see {@link StartProjectVersionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartProjectVersionCommand extends $Command<StartProjectVersionCommandInput, StartProjectVersionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartProjectVersionCommandInput;
     constructor(input: StartProjectVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartProjectVersionCommandInput, StartProjectVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface StartSegmentDetectionCommandInput extends StartSegmentDetection
 }
 export interface StartSegmentDetectionCommandOutput extends StartSegmentDetectionResponse, __MetadataBearer {
 }
-/**
- * <p>Starts asynchronous detection of segment detection in a stored video.</p>
- *          <p>Amazon Rekognition Video can detect segments in a video stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name and
- *       the filename of the video. <code>StartSegmentDetection</code> returns a job identifier (<code>JobId</code>) which you use to get
- *       the results of the operation. When segment detection is finished, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service topic
- *       that you specify in <code>NotificationChannel</code>.</p>
- *          <p>You can use the <code>Filters</code> (<a>StartSegmentDetectionFilters</a>)
- *       input parameter to specify the minimum detection confidence returned in the response.
- *       Within <code>Filters</code>, use <code>ShotFilter</code> (<a>StartShotDetectionFilter</a>)
- *       to filter detected shots. Use  <code>TechnicalCueFilter</code> (<a>StartTechnicalCueDetectionFilter</a>)
- *       to filter technical cues. </p>
- *          <p>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 <a>GetSegmentDetection</a> and pass the job identifier (<code>JobId</code>)
- *       from the initial call to <code>StartSegmentDetection</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, StartSegmentDetectionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartSegmentDetectionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartSegmentDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartSegmentDetectionCommandInput} for command's `input` shape.
- * @see {@link StartSegmentDetectionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartSegmentDetectionCommand extends $Command<StartSegmentDetectionCommandInput, StartSegmentDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartSegmentDetectionCommandInput;
     constructor(input: StartSegmentDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSegmentDetectionCommandInput, StartSegmentDetectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface StartStreamProcessorCommandInput extends StartStreamProcessorRe
 }
 export interface StartStreamProcessorCommandOutput extends StartStreamProcessorResponse, __MetadataBearer {
 }
-/**
- * <p>Starts processing a stream processor. You create a stream processor by calling <a>CreateStreamProcessor</a>.
- *             To tell <code>StartStreamProcessor</code> which stream processor to start, use the value of the <code>Name</code> field specified in the call to
- *             <code>CreateStreamProcessor</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, StartStreamProcessorCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, StartStreamProcessorCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new StartStreamProcessorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartStreamProcessorCommandInput} for command's `input` shape.
- * @see {@link StartStreamProcessorCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartStreamProcessorCommand extends $Command<StartStreamProcessorCommandInput, StartStreamProcessorCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartStreamProcessorCommandInput;
     constructor(input: StartStreamProcessorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartStreamProcessorCommandInput, StartStreamProcessorCommandOutput>;
     private serialize;
     private deserialize;