@aws-sdk/client-rekognition 3.296.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartContentModerationRequest, StartContentModerationResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartContentModerationCommand}.
  */
 export interface StartContentModerationCommandInput extends StartContentModerationRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartContentModerationCommand}.
  */
 export interface StartContentModerationCommandOutput extends StartContentModerationResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -35,6 +40,8 @@ export interface StartContentModerationCommandOutput extends StartContentModerat
  * const response = await client.send(command);
  * ```
  *
+ * @param StartContentModerationCommandInput - {@link StartContentModerationCommandInput}
+ * @returns {@link StartContentModerationCommandOutput}
  * @see {@link StartContentModerationCommandInput} for command's `input` shape.
  * @see {@link StartContentModerationCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -77,11 +84,20 @@ export interface StartContentModerationCommandOutput extends StartContentModerat
 export declare class StartContentModerationCommand extends $Command<StartContentModerationCommandInput, StartContentModerationCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartContentModerationCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartContentModerationCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartContentModerationCommandInput, StartContentModerationCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartFaceDetectionRequest, StartFaceDetectionResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartFaceDetectionCommand}.
  */
 export interface StartFaceDetectionCommandInput extends StartFaceDetectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartFaceDetectionCommand}.
  */
 export interface StartFaceDetectionCommandOutput extends StartFaceDetectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -36,6 +41,8 @@ export interface StartFaceDetectionCommandOutput extends StartFaceDetectionRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param StartFaceDetectionCommandInput - {@link StartFaceDetectionCommandInput}
+ * @returns {@link StartFaceDetectionCommandOutput}
  * @see {@link StartFaceDetectionCommandInput} for command's `input` shape.
  * @see {@link StartFaceDetectionCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -78,11 +85,20 @@ export interface StartFaceDetectionCommandOutput extends StartFaceDetectionRespo
 export declare class StartFaceDetectionCommand extends $Command<StartFaceDetectionCommandInput, StartFaceDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartFaceDetectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartFaceDetectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartFaceDetectionCommandInput, StartFaceDetectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartFaceSearchRequest, StartFaceSearchResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartFaceSearchCommand}.
  */
 export interface StartFaceSearchCommandInput extends StartFaceSearchRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartFaceSearchCommand}.
  */
 export interface StartFaceSearchCommandOutput extends StartFaceSearchResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -35,6 +40,8 @@ export interface StartFaceSearchCommandOutput extends StartFaceSearchResponse, _
  * const response = await client.send(command);
  * ```
  *
+ * @param StartFaceSearchCommandInput - {@link StartFaceSearchCommandInput}
+ * @returns {@link StartFaceSearchCommandOutput}
  * @see {@link StartFaceSearchCommandInput} for command's `input` shape.
  * @see {@link StartFaceSearchCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -80,11 +87,20 @@ export interface StartFaceSearchCommandOutput extends StartFaceSearchResponse, _
 export declare class StartFaceSearchCommand extends $Command<StartFaceSearchCommandInput, StartFaceSearchCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartFaceSearchCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartFaceSearchCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartFaceSearchCommandInput, StartFaceSearchCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartLabelDetectionRequest, StartLabelDetectionResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartLabelDetectionCommand}.
  */
 export interface StartLabelDetectionCommandInput extends StartLabelDetectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartLabelDetectionCommand}.
  */
 export interface StartLabelDetectionCommandOutput extends StartLabelDetectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -49,6 +54,8 @@ export interface StartLabelDetectionCommandOutput extends StartLabelDetectionRes
  * const response = await client.send(command);
  * ```
  *
+ * @param StartLabelDetectionCommandInput - {@link StartLabelDetectionCommandInput}
+ * @returns {@link StartLabelDetectionCommandOutput}
  * @see {@link StartLabelDetectionCommandInput} for command's `input` shape.
  * @see {@link StartLabelDetectionCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -91,11 +98,20 @@ export interface StartLabelDetectionCommandOutput extends StartLabelDetectionRes
 export declare class StartLabelDetectionCommand extends $Command<StartLabelDetectionCommandInput, StartLabelDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartLabelDetectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartLabelDetectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartLabelDetectionCommandInput, StartLabelDetectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartPersonTrackingRequest, StartPersonTrackingResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartPersonTrackingCommand}.
  */
 export interface StartPersonTrackingCommandInput extends StartPersonTrackingRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartPersonTrackingCommand}.
  */
 export interface StartPersonTrackingCommandOutput extends StartPersonTrackingResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -33,6 +38,8 @@ export interface StartPersonTrackingCommandOutput extends StartPersonTrackingRes
  * const response = await client.send(command);
  * ```
  *
+ * @param StartPersonTrackingCommandInput - {@link StartPersonTrackingCommandInput}
+ * @returns {@link StartPersonTrackingCommandOutput}
  * @see {@link StartPersonTrackingCommandInput} for command's `input` shape.
  * @see {@link StartPersonTrackingCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -75,11 +82,20 @@ export interface StartPersonTrackingCommandOutput extends StartPersonTrackingRes
 export declare class StartPersonTrackingCommand extends $Command<StartPersonTrackingCommandInput, StartPersonTrackingCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartPersonTrackingCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartPersonTrackingCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartPersonTrackingCommandInput, StartPersonTrackingCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartProjectVersionRequest, StartProjectVersionResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartProjectVersionCommand}.
  */
 export interface StartProjectVersionCommandInput extends StartProjectVersionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartProjectVersionCommand}.
  */
 export interface StartProjectVersionCommandOutput extends StartProjectVersionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -35,6 +40,8 @@ export interface StartProjectVersionCommandOutput extends StartProjectVersionRes
  * const response = await client.send(command);
  * ```
  *
+ * @param StartProjectVersionCommandInput - {@link StartProjectVersionCommandInput}
+ * @returns {@link StartProjectVersionCommandOutput}
  * @see {@link StartProjectVersionCommandInput} for command's `input` shape.
  * @see {@link StartProjectVersionCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -72,11 +79,20 @@ export interface StartProjectVersionCommandOutput extends StartProjectVersionRes
 export declare class StartProjectVersionCommand extends $Command<StartProjectVersionCommandInput, StartProjectVersionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartProjectVersionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartProjectVersionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartProjectVersionCommandInput, StartProjectVersionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartSegmentDetectionRequest, StartSegmentDetectionResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartSegmentDetectionCommand}.
  */
 export interface StartSegmentDetectionCommandInput extends StartSegmentDetectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartSegmentDetectionCommand}.
  */
 export interface StartSegmentDetectionCommandOutput extends StartSegmentDetectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -38,6 +43,8 @@ export interface StartSegmentDetectionCommandOutput extends StartSegmentDetectio
  * const response = await client.send(command);
  * ```
  *
+ * @param StartSegmentDetectionCommandInput - {@link StartSegmentDetectionCommandInput}
+ * @returns {@link StartSegmentDetectionCommandOutput}
  * @see {@link StartSegmentDetectionCommandInput} for command's `input` shape.
  * @see {@link StartSegmentDetectionCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -80,11 +87,20 @@ export interface StartSegmentDetectionCommandOutput extends StartSegmentDetectio
 export declare class StartSegmentDetectionCommand extends $Command<StartSegmentDetectionCommandInput, StartSegmentDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartSegmentDetectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartSegmentDetectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSegmentDetectionCommandInput, StartSegmentDetectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartStreamProcessorRequest, StartStreamProcessorResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartStreamProcessorCommand}.
  */
 export interface StartStreamProcessorCommandInput extends StartStreamProcessorRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartStreamProcessorCommand}.
  */
 export interface StartStreamProcessorCommandOutput extends StartStreamProcessorResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -28,6 +33,8 @@ export interface StartStreamProcessorCommandOutput extends StartStreamProcessorR
  * const response = await client.send(command);
  * ```
  *
+ * @param StartStreamProcessorCommandInput - {@link StartStreamProcessorCommandInput}
+ * @returns {@link StartStreamProcessorCommandOutput}
  * @see {@link StartStreamProcessorCommandInput} for command's `input` shape.
  * @see {@link StartStreamProcessorCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -60,11 +67,20 @@ export interface StartStreamProcessorCommandOutput extends StartStreamProcessorR
 export declare class StartStreamProcessorCommand extends $Command<StartStreamProcessorCommandInput, StartStreamProcessorCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartStreamProcessorCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartStreamProcessorCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartStreamProcessorCommandInput, StartStreamProcessorCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StartTextDetectionRequest, StartTextDetectionResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StartTextDetectionCommand}.
  */
 export interface StartTextDetectionCommandInput extends StartTextDetectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StartTextDetectionCommand}.
  */
 export interface StartTextDetectionCommandOutput extends StartTextDetectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Starts asynchronous detection of text in a stored video.</p>
  *          <p>Amazon Rekognition Video can detect text 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>StartTextDetection</code> returns a job identifier (<code>JobId</code>) which you use to get
@@ -32,6 +37,8 @@ export interface StartTextDetectionCommandOutput extends StartTextDetectionRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param StartTextDetectionCommandInput - {@link StartTextDetectionCommandInput}
+ * @returns {@link StartTextDetectionCommandOutput}
  * @see {@link StartTextDetectionCommandInput} for command's `input` shape.
  * @see {@link StartTextDetectionCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -74,11 +81,20 @@ export interface StartTextDetectionCommandOutput extends StartTextDetectionRespo
 export declare class StartTextDetectionCommand extends $Command<StartTextDetectionCommandInput, StartTextDetectionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StartTextDetectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StartTextDetectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartTextDetectionCommandInput, StartTextDetectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StopProjectVersionRequest, StopProjectVersionResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StopProjectVersionCommand}.
  */
 export interface StopProjectVersionCommandInput extends StopProjectVersionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StopProjectVersionCommand}.
  */
 export interface StopProjectVersionCommandOutput extends StopProjectVersionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Stops a running model. The operation might take a while to complete. To
  *          check the current status, call <a>DescribeProjectVersions</a>. </p>
  * @example
@@ -26,6 +31,8 @@ export interface StopProjectVersionCommandOutput extends StopProjectVersionRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param StopProjectVersionCommandInput - {@link StopProjectVersionCommandInput}
+ * @returns {@link StopProjectVersionCommandOutput}
  * @see {@link StopProjectVersionCommandInput} for command's `input` shape.
  * @see {@link StopProjectVersionCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -58,11 +65,20 @@ export interface StopProjectVersionCommandOutput extends StopProjectVersionRespo
 export declare class StopProjectVersionCommand extends $Command<StopProjectVersionCommandInput, StopProjectVersionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StopProjectVersionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StopProjectVersionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopProjectVersionCommandInput, StopProjectVersionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { StopStreamProcessorRequest, StopStreamProcessorResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link StopStreamProcessorCommand}.
  */
 export interface StopStreamProcessorCommandInput extends StopStreamProcessorRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link StopStreamProcessorCommand}.
  */
 export interface StopStreamProcessorCommandOutput extends StopStreamProcessorResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Stops a running stream processor that was created by <a>CreateStreamProcessor</a>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface StopStreamProcessorCommandOutput extends StopStreamProcessorRes
  * const response = await client.send(command);
  * ```
  *
+ * @param StopStreamProcessorCommandInput - {@link StopStreamProcessorCommandInput}
+ * @returns {@link StopStreamProcessorCommandOutput}
  * @see {@link StopStreamProcessorCommandInput} for command's `input` shape.
  * @see {@link StopStreamProcessorCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -57,11 +64,20 @@ export interface StopStreamProcessorCommandOutput extends StopStreamProcessorRes
 export declare class StopStreamProcessorCommand extends $Command<StopStreamProcessorCommandInput, StopStreamProcessorCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: StopStreamProcessorCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: StopStreamProcessorCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopStreamProcessorCommandInput, StopStreamProcessorCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
 import { RekognitionClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RekognitionClient";
 /**
+ * @public
+ *
  * The input for {@link TagResourceCommand}.
  */
 export interface TagResourceCommandInput extends TagResourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link TagResourceCommand}.
  */
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p> Adds one or more key-value tags to an Amazon Rekognition collection, stream processor, or Custom
  *       Labels model. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS
  *         Resources</a>. </p>
@@ -29,6 +34,8 @@ export interface TagResourceCommandOutput extends TagResourceResponse, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param TagResourceCommandInput - {@link TagResourceCommandInput}
+ * @returns {@link TagResourceCommandOutput}
  * @see {@link TagResourceCommandInput} for command's `input` shape.
  * @see {@link TagResourceCommandOutput} for command's `response` shape.
  * @see {@link RekognitionClientResolvedConfig | config} for RekognitionClient's `config` shape.
@@ -63,11 +70,20 @@ export interface TagResourceCommandOutput extends TagResourceResponse, __Metadat
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: TagResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }