@aws-sdk/client-rekognition 3.36.0 → 3.39.0

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

@@ -6,33 +6,11 @@ export interface DescribeProjectVersionsCommandInput extends DescribeProjectVers
 }
 export interface DescribeProjectVersionsCommandOutput extends DescribeProjectVersionsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists and describes the models in an Amazon Rekognition Custom Labels project. You
- *          can specify up to 10 model versions in <code>ProjectVersionArns</code>. If
- *          you don't specify a value, descriptions for all models are returned.</p>
- *          <p>This operation requires permissions to perform the <code>rekognition:DescribeProjectVersions</code>
- *             action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, DescribeProjectVersionsCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DescribeProjectVersionsCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DescribeProjectVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeProjectVersionsCommandInput} for command's `input` shape.
- * @see {@link DescribeProjectVersionsCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeProjectVersionsCommand extends $Command<DescribeProjectVersionsCommandInput, DescribeProjectVersionsCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DescribeProjectVersionsCommandInput;
     constructor(input: DescribeProjectVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeProjectVersionsCommandInput, DescribeProjectVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeProjectsCommandInput extends DescribeProjectsRequest {
 }
 export interface DescribeProjectsCommandOutput extends DescribeProjectsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists and gets information about your Amazon Rekognition Custom Labels projects.</p>
- *          <p>This operation requires permissions to perform the <code>rekognition:DescribeProjects</code> action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, DescribeProjectsCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DescribeProjectsCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DescribeProjectsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeProjectsCommandInput} for command's `input` shape.
- * @see {@link DescribeProjectsCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeProjectsCommand extends $Command<DescribeProjectsCommandInput, DescribeProjectsCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DescribeProjectsCommandInput;
     constructor(input: DescribeProjectsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeProjectsCommandInput, DescribeProjectsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeStreamProcessorCommandInput extends DescribeStreamProce
 }
 export interface DescribeStreamProcessorCommandOutput extends DescribeStreamProcessorResponse, __MetadataBearer {
 }
-/**
- * <p>Provides information about a stream processor created by <a>CreateStreamProcessor</a>. You can get information about the input and output streams, the input parameters for the face recognition being performed,
- *             and the current status of the stream processor.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, DescribeStreamProcessorCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DescribeStreamProcessorCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DescribeStreamProcessorCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeStreamProcessorCommandInput} for command's `input` shape.
- * @see {@link DescribeStreamProcessorCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeStreamProcessorCommand extends $Command<DescribeStreamProcessorCommandInput, DescribeStreamProcessorCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DescribeStreamProcessorCommandInput;
     constructor(input: DescribeStreamProcessorCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStreamProcessorCommandInput, DescribeStreamProcessorCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,79 +6,11 @@ export interface DetectCustomLabelsCommandInput extends DetectCustomLabelsReques
 }
 export interface DetectCustomLabelsCommandOutput extends DetectCustomLabelsResponse, __MetadataBearer {
 }
-/**
- * <p>Detects custom labels in a supplied image by using an Amazon Rekognition Custom Labels model. </p>
- *          <p>You specify which version of a model version to use by using the <code>ProjectVersionArn</code> input
- *       parameter. </p>
- *          <p>You pass the input image 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 each object that the model version detects on an image, the API returns a
- *          (<code>CustomLabel</code>) object in an array (<code>CustomLabels</code>).
- *          Each <code>CustomLabel</code> object provides the label name (<code>Name</code>), the level
- *          of confidence that the image contains the object (<code>Confidence</code>), and
- *          object location information, if it exists,  for the label on the image (<code>Geometry</code>). </p>
- *
- *
- *
- *
- *
- *
- *
- *
- *
- *
- *          <p>To filter labels that are returned, specify a value for <code>MinConfidence</code>.
- *          <code>DetectCustomLabelsLabels</code> only returns labels with a confidence that's higher than
- *          the specified value.
- *
- *          The value of <code>MinConfidence</code> maps to the assumed threshold values
- *          created during training. For more information, see <i>Assumed threshold</i>
- *          in the Amazon Rekognition Custom Labels Developer Guide.
- *          Amazon Rekognition Custom Labels metrics expresses an assumed threshold as a floating point value between 0-1. The range of
- *          <code>MinConfidence</code> normalizes the threshold value to a percentage value (0-100). Confidence
- *          responses from <code>DetectCustomLabels</code> are also returned as a percentage.
- *          You can use <code>MinConfidence</code> to change the precision and recall or your model.
- *          For more information, see
- *          <i>Analyzing an image</i> in the Amazon Rekognition Custom Labels Developer Guide. </p>
- *
- *          <p>If you don't specify a value for <code>MinConfidence</code>,  <code>DetectCustomLabels</code>
- *       returns labels based on the assumed threshold of each label.</p>
- *
- *
- *
- *
- *
- *          <p>This is a stateless API operation. That is, the operation does not persist any
- *          data.</p>
- *          <p>This operation requires permissions to perform the
- *          <code>rekognition:DetectCustomLabels</code> action. </p>
- *
- *
- *
- *          <p>For more information, see
- *       <i>Analyzing an image</i> in the Amazon Rekognition Custom Labels Developer Guide. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, DetectCustomLabelsCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DetectCustomLabelsCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DetectCustomLabelsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectCustomLabelsCommandInput} for command's `input` shape.
- * @see {@link DetectCustomLabelsCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectCustomLabelsCommand extends $Command<DetectCustomLabelsCommandInput, DetectCustomLabelsCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DetectCustomLabelsCommandInput;
     constructor(input: DetectCustomLabelsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectCustomLabelsCommandInput, DetectCustomLabelsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,51 +6,11 @@ export interface DetectFacesCommandInput extends DetectFacesRequest {
 }
 export interface DetectFacesCommandOutput extends DetectFacesResponse, __MetadataBearer {
 }
-/**
- * <p>Detects faces within an image that is provided as input.</p>
- *
- *          <p>
- *             <code>DetectFaces</code> detects the 100 largest faces in the image. For each face
- *       detected, the operation returns face details. These details include a bounding box of the
- *       face, a confidence value (that the bounding box contains a face), and a fixed set of
- *       attributes such as facial landmarks (for example, coordinates of eye and mouth),
- *       presence of beard, sunglasses, and so on. </p>
- *          <p>The face-detection algorithm is most effective on frontal faces. For non-frontal or
- *       obscured faces, the algorithm might not detect the faces or might detect faces with lower
- *       confidence. </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>
- *
- *          <note>
- *             <p>This is a stateless API operation. That is, the operation does not persist any
- *         data.</p>
- *          </note>
- *
- *          <p>This operation requires permissions to perform the
- *       <code>rekognition:DetectFaces</code> action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, DetectFacesCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DetectFacesCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DetectFacesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectFacesCommandInput} for command's `input` shape.
- * @see {@link DetectFacesCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectFacesCommand extends $Command<DetectFacesCommandInput, DetectFacesCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DetectFacesCommandInput;
     constructor(input: DetectFacesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectFacesCommandInput, DetectFacesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,101 +6,11 @@ export interface DetectLabelsCommandInput extends DetectLabelsRequest {
 }
 export interface DetectLabelsCommandOutput extends DetectLabelsResponse, __MetadataBearer {
 }
-/**
- * <p>Detects instances of real-world entities within an image (JPEG or PNG)
- *        provided as input. This includes objects like flower, tree, and table; events like
- *        wedding, graduation, and birthday party; and concepts like landscape, evening, and nature.
- *      </p>
- *
- *          <p>For an example, see Analyzing Images Stored in an Amazon S3 Bucket in the Amazon Rekognition Developer Guide.</p>
- *          <note>
- *             <p>
- *                <code>DetectLabels</code> does not support the detection of activities. However, activity detection
- *         is supported for label detection in videos. For more information, see StartLabelDetection in the Amazon Rekognition Developer Guide.</p>
- *          </note>
- *
- *          <p>You pass the input image 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 each object, scene, and concept the API returns one or more labels. Each label
- *       provides the object name, and the level of confidence that the image contains the object. For
- *       example, suppose the input image has a lighthouse, the sea, and a rock. The response includes
- *       all three labels, one for each object. </p>
- *
- *          <p>
- *             <code>{Name: lighthouse, Confidence: 98.4629}</code>
- *          </p>
- *          <p>
- *             <code>{Name: rock,Confidence: 79.2097}</code>
- *          </p>
- *          <p>
- *             <code> {Name: sea,Confidence: 75.061}</code>
- *          </p>
- *          <p>In the preceding example, the operation returns one label for each of the three
- *       objects. The operation can also return multiple labels for the same object in the image. For
- *       example, if the input image shows a flower (for example, a tulip), the operation might return
- *       the following three labels. </p>
- *          <p>
- *             <code>{Name: flower,Confidence: 99.0562}</code>
- *          </p>
- *          <p>
- *             <code>{Name: plant,Confidence: 99.0562}</code>
- *          </p>
- *          <p>
- *             <code>{Name: tulip,Confidence: 99.0562}</code>
- *          </p>
- *
- *          <p>In this example, the detection algorithm more precisely identifies the flower as a
- *       tulip.</p>
- *          <p>In response, the API returns an array of labels. In addition, the response also
- *       includes the orientation correction. Optionally, you can specify <code>MinConfidence</code> to
- *       control the confidence threshold for the labels returned. The default is 55%. You can also add
- *       the <code>MaxLabels</code> parameter to limit the number of labels returned. </p>
- *          <note>
- *             <p>If the object detected is a person, the operation doesn't provide the same facial
- *         details that the <a>DetectFaces</a> operation provides.</p>
- *          </note>
- *          <p>
- *             <code>DetectLabels</code> returns bounding boxes for instances of common object labels in an array of
- *       <a>Instance</a> objects. An <code>Instance</code> object contains a
- *       <a>BoundingBox</a> object, for the location of the label on the image. It also includes
- *       the confidence by which the bounding box was detected.</p>
- *          <p>
- *             <code>DetectLabels</code> also returns a hierarchical taxonomy of detected labels. For example,
- *       a detected car might be assigned the label <i>car</i>. The label <i>car</i>
- *       has two parent labels: <i>Vehicle</i> (its parent) and <i>Transportation</i> (its
- *       grandparent).
- *       The response returns the entire list of ancestors for a label. Each ancestor is a unique label in the response.
- *       In the previous example, <i>Car</i>, <i>Vehicle</i>, and <i>Transportation</i>
- *       are returned as unique labels in the response.
- *       </p>
- *          <p>This is a stateless API operation. That is, the operation does not persist any
- *       data.</p>
- *          <p>This operation requires permissions to perform the
- *         <code>rekognition:DetectLabels</code> action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, DetectLabelsCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DetectLabelsCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DetectLabelsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectLabelsCommandInput} for command's `input` shape.
- * @see {@link DetectLabelsCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectLabelsCommand extends $Command<DetectLabelsCommandInput, DetectLabelsCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DetectLabelsCommandInput;
     constructor(input: DetectLabelsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectLabelsCommandInput, DetectLabelsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface DetectModerationLabelsCommandInput extends DetectModerationLabe
 }
 export interface DetectModerationLabelsCommandOutput extends DetectModerationLabelsResponse, __MetadataBearer {
 }
-/**
- * <p>Detects unsafe content in a specified JPEG or PNG format image.
- *      Use <code>DetectModerationLabels</code> to moderate images depending on your requirements.
- *      For example, you might want to filter images that contain nudity, but not images containing
- *      suggestive content.</p>
- *          <p>To filter images, use the labels returned by <code>DetectModerationLabels</code>
- *      to determine which types of content are appropriate.</p>
- *
- *          <p>For information about moderation labels,
- *       see Detecting Unsafe Content in the Amazon Rekognition Developer Guide.</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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, DetectModerationLabelsCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DetectModerationLabelsCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DetectModerationLabelsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectModerationLabelsCommandInput} for command's `input` shape.
- * @see {@link DetectModerationLabelsCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectModerationLabelsCommand extends $Command<DetectModerationLabelsCommandInput, DetectModerationLabelsCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DetectModerationLabelsCommandInput;
     constructor(input: DetectModerationLabelsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectModerationLabelsCommandInput, DetectModerationLabelsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,68 +6,11 @@ export interface DetectProtectiveEquipmentCommandInput extends DetectProtectiveE
 }
 export interface DetectProtectiveEquipmentCommandOutput extends DetectProtectiveEquipmentResponse, __MetadataBearer {
 }
-/**
- * <p>Detects Personal Protective Equipment (PPE) worn by people detected in an image. Amazon Rekognition can detect the
- *          following types of PPE.</p>
- *          <ul>
- *             <li>
- *                <p>Face cover</p>
- *             </li>
- *             <li>
- *                <p>Hand cover</p>
- *             </li>
- *             <li>
- *                <p>Head cover</p>
- *             </li>
- *          </ul>
- *
- *          <p>You pass the input image as base64-encoded image bytes or as a reference to an image in an Amazon S3 bucket.
- *          The image must be either a PNG or JPG formatted file. </p>
- *
- *          <p>
- *             <code>DetectProtectiveEquipment</code> detects PPE worn by up to 15 persons detected in an image.</p>
- *          <p>For each person detected in the image the API returns an array of body parts (face, head, left-hand, right-hand).
- *          For each body part, an array of detected items of PPE is returned, including an indicator of whether or not the PPE
- *          covers the body part. The API returns the confidence it has in each detection
- *          (person, PPE, body part and body part coverage). It also returns a bounding box (<a>BoundingBox</a>) for each detected
- *          person and each detected item of PPE. </p>
- *          <p>You can optionally request a summary of detected PPE items with the <code>SummarizationAttributes</code> input parameter.
- *          The summary provides the following information. </p>
- *          <ul>
- *             <li>
- *                <p>The persons detected as wearing all of the types of PPE that you specify.</p>
- *             </li>
- *             <li>
- *                <p>The persons detected as not wearing all of the types PPE that you specify.</p>
- *             </li>
- *             <li>
- *                <p>The persons detected where PPE adornment could not be determined. </p>
- *             </li>
- *          </ul>
- *          <p>This is a stateless API operation. That is, the operation does not persist any data.</p>
- *
- *          <p>This operation requires permissions to perform the <code>rekognition:DetectProtectiveEquipment</code> action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, DetectProtectiveEquipmentCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DetectProtectiveEquipmentCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DetectProtectiveEquipmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectProtectiveEquipmentCommandInput} for command's `input` shape.
- * @see {@link DetectProtectiveEquipmentCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectProtectiveEquipmentCommand extends $Command<DetectProtectiveEquipmentCommandInput, DetectProtectiveEquipmentCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DetectProtectiveEquipmentCommandInput;
     constructor(input: DetectProtectiveEquipmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectProtectiveEquipmentCommandInput, DetectProtectiveEquipmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,50 +6,11 @@ export interface DetectTextCommandInput extends DetectTextRequest {
 }
 export interface DetectTextCommandOutput extends DetectTextResponse, __MetadataBearer {
 }
-/**
- * <p>Detects text in the input image and converts it into machine-readable text.</p>
- *          <p>Pass the input image 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, you must pass it as a
- *       reference to an image in an Amazon S3 bucket. For the AWS CLI, passing image bytes is not
- *       supported. The image must be either a .png or .jpeg formatted file. </p>
- *          <p>The <code>DetectText</code> operation returns text in an array of <a>TextDetection</a> elements, <code>TextDetections</code>. Each
- *         <code>TextDetection</code> element provides information about a single word or line of text
- *       that was detected in the image. </p>
- *          <p>A word is one or more ISO basic latin script characters that are not separated by spaces.
- *         <code>DetectText</code> can detect up to 100 words in an image.</p>
- *          <p>A line is a string of equally spaced words. A line isn't necessarily a complete
- *       sentence. For example, a driver's license number is detected as a line. A line ends when there
- *       is no aligned text after it. Also, a line ends when there is a large gap between words,
- *       relative to the length of the words. This means, depending on the gap between words, Amazon Rekognition
- *       may detect multiple lines in text aligned in the same direction. Periods don't represent the
- *       end of a line. If a sentence spans multiple lines, the <code>DetectText</code> operation
- *       returns multiple lines.</p>
- *          <p>To determine whether a <code>TextDetection</code> element is a line of text or a word,
- *       use the <code>TextDetection</code> object <code>Type</code> field. </p>
- *          <p>To be detected, text must be within +/- 90 degrees orientation of the horizontal axis.</p>
- *
- *          <p>For more information, see DetectText 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, DetectTextCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, DetectTextCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new DetectTextCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectTextCommandInput} for command's `input` shape.
- * @see {@link DetectTextCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectTextCommand extends $Command<DetectTextCommandInput, DetectTextCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: DetectTextCommandInput;
     constructor(input: DetectTextCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectTextCommandInput, DetectTextCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface GetCelebrityInfoCommandInput extends GetCelebrityInfoRequest {
 }
 export interface GetCelebrityInfoCommandOutput extends GetCelebrityInfoResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the name and additional information about a celebrity based on their Amazon Rekognition ID.
- *       The additional information is returned as an array of URLs. If there is no additional
- *       information about the celebrity, this list is empty.</p>
- *
- *          <p>For more information, see Recognizing Celebrities in an Image in
- *       the Amazon Rekognition Developer Guide.</p>
- *          <p>This operation requires permissions to perform the
- *         <code>rekognition:GetCelebrityInfo</code> action. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetCelebrityInfoCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetCelebrityInfoCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetCelebrityInfoCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCelebrityInfoCommandInput} for command's `input` shape.
- * @see {@link GetCelebrityInfoCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCelebrityInfoCommand extends $Command<GetCelebrityInfoCommandInput, GetCelebrityInfoCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetCelebrityInfoCommandInput;
     constructor(input: GetCelebrityInfoCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCelebrityInfoCommandInput, GetCelebrityInfoCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,63 +6,11 @@ export interface GetCelebrityRecognitionCommandInput extends GetCelebrityRecogni
 }
 export interface GetCelebrityRecognitionCommandOutput extends GetCelebrityRecognitionResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the celebrity recognition results for a Amazon Rekognition Video analysis started by
- *      <a>StartCelebrityRecognition</a>.</p>
- *          <p>Celebrity recognition in a video is an asynchronous operation. Analysis is started by a call
- *       to <a>StartCelebrityRecognition</a>  which returns a job identifier (<code>JobId</code>).
- *       When the celebrity recognition operation finishes, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service
- *       topic registered in the initial call to <code>StartCelebrityRecognition</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  <code>GetCelebrityDetection</code> and pass the job identifier
- *       (<code>JobId</code>) from the initial call to <code>StartCelebrityDetection</code>. </p>
- *
- *          <p>For more information, see Working With Stored Videos in the Amazon Rekognition Developer Guide.</p>
- *          <p>
- *             <code>GetCelebrityRecognition</code> returns detected celebrities and the time(s) they are detected in an array
- *       (<code>Celebrities</code>) of <a>CelebrityRecognition</a>
- *       objects. Each <code>CelebrityRecognition</code> contains information about the celebrity in a <a>CelebrityDetail</a>
- *       object and the time, <code>Timestamp</code>, the celebrity was detected.
- *       </p>
- *          <note>
- *             <p>
- *                <code>GetCelebrityRecognition</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>Celebrities</code> array is sorted by time (milliseconds from the start of the video).
- *       You can also sort the array by celebrity by specifying the value <code>ID</code> in the <code>SortBy</code> input parameter.</p>
- *          <p>The <code>CelebrityDetail</code> object includes the celebrity identifer and additional information urls. If you don't store
- *       the additional information urls, you can get them later by calling <a>GetCelebrityInfo</a> with the celebrity identifer.</p>
- *          <p>No information is returned for faces not recognized as celebrities.</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>GetCelebrityDetection</code>
- *       and populate the <code>NextToken</code> request parameter with the token
- *       value returned from the previous call to <code>GetCelebrityRecognition</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { RekognitionClient, GetCelebrityRecognitionCommand } from "@aws-sdk/client-rekognition"; // ES Modules import
- * // const { RekognitionClient, GetCelebrityRecognitionCommand } = require("@aws-sdk/client-rekognition"); // CommonJS import
- * const client = new RekognitionClient(config);
- * const command = new GetCelebrityRecognitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCelebrityRecognitionCommandInput} for command's `input` shape.
- * @see {@link GetCelebrityRecognitionCommandOutput} for command's `response` shape.
- * @see {@link RekognitionClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCelebrityRecognitionCommand extends $Command<GetCelebrityRecognitionCommandInput, GetCelebrityRecognitionCommandOutput, RekognitionClientResolvedConfig> {
     readonly input: GetCelebrityRecognitionCommandInput;
     constructor(input: GetCelebrityRecognitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RekognitionClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCelebrityRecognitionCommandInput, GetCelebrityRecognitionCommandOutput>;
     private serialize;
     private deserialize;