@aws-sdk/client-textract 3.36.0 → 3.36.1

package/dist-types/ts3.4/Textract.d.ts

@@ -7,205 +7,33 @@ import { GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOu
 import { StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput } from "./commands/StartDocumentAnalysisCommand";
 import { StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput } from "./commands/StartDocumentTextDetectionCommand";
 import { TextractClient } from "./TextractClient";
-/**
- * <p>Amazon Textract detects and analyzes text in documents and converts it
- *          into machine-readable text. This is the API reference documentation for
- *          Amazon Textract.</p>
- */
+
 export declare class Textract extends TextractClient {
-    /**
-     * <p>Analyzes an input document for relationships between detected items.  </p>
-     *          <p>The types of information returned are as follows: </p>
-     *          <ul>
-     *             <li>
-     *                <p>Form data (key-value pairs). The related information is returned in two <a>Block</a> objects, each of type <code>KEY_VALUE_SET</code>: a KEY
-     *                   <code>Block</code> object and a VALUE <code>Block</code> object. For example,
-     *                   <i>Name: Ana Silva Carolina</i> contains a key and value.
-     *                   <i>Name:</i> is the key. <i>Ana Silva Carolina</i> is
-     *                the value.</p>
-     *             </li>
-     *             <li>
-     *                <p>Table and table cell data. A TABLE <code>Block</code> object contains information about a detected table. A CELL
-     *                <code>Block</code> object is returned for each cell in a table.</p>
-     *             </li>
-     *             <li>
-     *                <p>Lines and words of text. A LINE <code>Block</code> object contains one or more WORD <code>Block</code> objects.
-     *         All lines and words that are detected in the document are returned (including text that doesn't have a
-     *                relationship with the value of <code>FeatureTypes</code>). </p>
-     *             </li>
-     *          </ul>
-     *
-     *          <p>Selection elements such as check boxes and option buttons (radio buttons) can be detected in form data and in tables.
-     *          A SELECTION_ELEMENT <code>Block</code> object contains information about a selection element,
-     *          including the selection status.</p>
-     *          <p>You can choose which type of analysis to perform by specifying the <code>FeatureTypes</code> list.
-     *       </p>
-     *          <p>The output is returned in a list of <code>Block</code> objects.</p>
-     *          <p>
-     *             <code>AnalyzeDocument</code> is a synchronous operation. To analyze documents
-     *       asynchronously, use <a>StartDocumentAnalysis</a>.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html">Document Text Analysis</a>.</p>
-     */
+    
     analyzeDocument(args: AnalyzeDocumentCommandInput, options?: __HttpHandlerOptions): Promise<AnalyzeDocumentCommandOutput>;
     analyzeDocument(args: AnalyzeDocumentCommandInput, cb: (err: any, data?: AnalyzeDocumentCommandOutput) => void): void;
     analyzeDocument(args: AnalyzeDocumentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AnalyzeDocumentCommandOutput) => void): void;
-    /**
-     * <p>Analyzes an input document for financially related relationships between text.</p>
-     *          <p>Information is returned as <code>ExpenseDocuments</code> and seperated as follows.</p>
-     *          <ul>
-     *             <li>
-     *                <p>
-     *                   <code>LineItemGroups</code>- A data set containing <code>LineItems</code> which
-     *          store information about the lines of text, such as an item purchased and its price on a receipt.</p>
-     *             </li>
-     *             <li>
-     *                <p>
-     *                   <code>SummaryFields</code>- Contains all other information a receipt, such as header information
-     *          or the vendors name.</p>
-     *             </li>
-     *          </ul>
-     */
+    
     analyzeExpense(args: AnalyzeExpenseCommandInput, options?: __HttpHandlerOptions): Promise<AnalyzeExpenseCommandOutput>;
     analyzeExpense(args: AnalyzeExpenseCommandInput, cb: (err: any, data?: AnalyzeExpenseCommandOutput) => void): void;
     analyzeExpense(args: AnalyzeExpenseCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AnalyzeExpenseCommandOutput) => void): void;
-    /**
-     * <p>Detects text in the input document. Amazon Textract can detect lines of text and the
-     *          words that make up a line of text. The input document must be an image in JPEG or PNG
-     *          format. <code>DetectDocumentText</code> returns the detected text in an array of <a>Block</a> objects. </p>
-     *          <p>Each document page has as an associated <code>Block</code> of type PAGE. Each PAGE <code>Block</code> object
-     *          is the parent of LINE <code>Block</code> objects that represent the lines of detected text on a page. A LINE <code>Block</code> object is
-     *          a parent for each word that makes up the line. Words are represented by <code>Block</code> objects of type WORD.</p>
-     *
-     *          <p>
-     *             <code>DetectDocumentText</code> is a synchronous operation. To analyze documents
-     *          asynchronously, use <a>StartDocumentTextDetection</a>.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html">Document Text Detection</a>.</p>
-     */
+    
     detectDocumentText(args: DetectDocumentTextCommandInput, options?: __HttpHandlerOptions): Promise<DetectDocumentTextCommandOutput>;
     detectDocumentText(args: DetectDocumentTextCommandInput, cb: (err: any, data?: DetectDocumentTextCommandOutput) => void): void;
     detectDocumentText(args: DetectDocumentTextCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DetectDocumentTextCommandOutput) => void): void;
-    /**
-     * <p>Gets the results for an Amazon Textract asynchronous operation that analyzes text in a document.</p>
-     *          <p>You start asynchronous text analysis by calling <a>StartDocumentAnalysis</a>, which returns a job identifier
-     *             (<code>JobId</code>). When the text analysis operation finishes, Amazon Textract publishes a
-     *          completion status to the Amazon Simple Notification Service (Amazon SNS) topic that's registered in the initial call to
-     *             <code>StartDocumentAnalysis</code>. To get the results of the text-detection operation,
-     *          first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
-     *          If so, call <code>GetDocumentAnalysis</code>, and pass the job identifier
-     *             (<code>JobId</code>) from the initial call to <code>StartDocumentAnalysis</code>.</p>
-     *          <p>
-     *             <code>GetDocumentAnalysis</code> returns an array of <a>Block</a> objects. The following
-     *          types of information are returned: </p>
-     *          <ul>
-     *             <li>
-     *                <p>Form data (key-value pairs). The related information is returned in two <a>Block</a> objects, each of type <code>KEY_VALUE_SET</code>: a KEY
-     *             <code>Block</code> object and a VALUE <code>Block</code> object. For example,
-     *             <i>Name: Ana Silva Carolina</i> contains a key and value.
-     *             <i>Name:</i> is the key. <i>Ana Silva Carolina</i> is
-     *             the value.</p>
-     *             </li>
-     *             <li>
-     *                <p>Table and table cell data. A TABLE <code>Block</code> object contains information about a detected table. A CELL
-     *             <code>Block</code> object is returned for each cell in a table.</p>
-     *             </li>
-     *             <li>
-     *                <p>Lines and words of text. A LINE <code>Block</code> object contains one or more WORD <code>Block</code> objects.
-     *             All lines and words that are detected in the document are returned (including text that doesn't have a
-     *             relationship with the value of the <code>StartDocumentAnalysis</code>
-     *                   <code>FeatureTypes</code> input parameter). </p>
-     *             </li>
-     *          </ul>
-     *
-     *          <p>Selection elements such as check boxes and option buttons (radio buttons) can be detected in form data and in tables.
-     *          A SELECTION_ELEMENT <code>Block</code> object contains information about a selection element,
-     *          including the selection status.</p>
-     *
-     *
-     *
-     *          <p>Use the <code>MaxResults</code> parameter to limit the number of blocks that are
-     *          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>GetDocumentAnalysis</code>, and populate the <code>NextToken</code> request
-     *          parameter with the token value that's returned from the previous call to
-     *             <code>GetDocumentAnalysis</code>.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html">Document Text Analysis</a>.</p>
-     */
+    
     getDocumentAnalysis(args: GetDocumentAnalysisCommandInput, options?: __HttpHandlerOptions): Promise<GetDocumentAnalysisCommandOutput>;
     getDocumentAnalysis(args: GetDocumentAnalysisCommandInput, cb: (err: any, data?: GetDocumentAnalysisCommandOutput) => void): void;
     getDocumentAnalysis(args: GetDocumentAnalysisCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDocumentAnalysisCommandOutput) => void): void;
-    /**
-     * <p>Gets the results for an Amazon Textract asynchronous operation that detects text in a document.
-     *      Amazon Textract can detect lines of text and the words that make up a line of text.</p>
-     *          <p>You start asynchronous text detection by calling <a>StartDocumentTextDetection</a>, which returns a job identifier
-     *             (<code>JobId</code>). When the text detection operation finishes, Amazon Textract publishes a
-     *          completion status to the Amazon Simple Notification Service (Amazon SNS) topic that's registered in the initial call to
-     *             <code>StartDocumentTextDetection</code>. To get the results of the text-detection
-     *          operation, first check that the status value published to the Amazon SNS topic is
-     *             <code>SUCCEEDED</code>. If so, call <code>GetDocumentTextDetection</code>, and pass the
-     *          job identifier (<code>JobId</code>) from the initial call to
-     *             <code>StartDocumentTextDetection</code>.</p>
-     *          <p>
-     *             <code>GetDocumentTextDetection</code> returns an array of <a>Block</a>
-     *          objects. </p>
-     *          <p>Each document page has as an associated <code>Block</code> of type PAGE. Each PAGE <code>Block</code> object
-     *         is the parent of LINE <code>Block</code> objects that represent the lines of detected text on a page. A LINE <code>Block</code> object is
-     *         a parent for each word that makes up the line. Words are represented by <code>Block</code> objects of type WORD.</p>
-     *
-     *          <p>Use the MaxResults parameter to limit the number of blocks that are 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>GetDocumentTextDetection</code>, and populate the <code>NextToken</code> request
-     *          parameter with the token value that's returned from the previous call to
-     *             <code>GetDocumentTextDetection</code>.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html">Document Text Detection</a>.</p>
-     */
+    
     getDocumentTextDetection(args: GetDocumentTextDetectionCommandInput, options?: __HttpHandlerOptions): Promise<GetDocumentTextDetectionCommandOutput>;
     getDocumentTextDetection(args: GetDocumentTextDetectionCommandInput, cb: (err: any, data?: GetDocumentTextDetectionCommandOutput) => void): void;
     getDocumentTextDetection(args: GetDocumentTextDetectionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDocumentTextDetectionCommandOutput) => void): void;
-    /**
-     * <p>Starts the asynchronous analysis of an input document for relationships between detected
-     *          items such as key-value pairs, tables, and selection elements.</p>
-     *
-     *          <p>
-     *             <code>StartDocumentAnalysis</code> can analyze text in documents that are in JPEG, PNG, and PDF format. The
-     *          documents are stored in an Amazon S3 bucket. Use <a>DocumentLocation</a> to specify the bucket name and file name
-     *          of the document.
-     *          </p>
-     *          <p>
-     *             <code>StartDocumentAnalysis</code> returns a job identifier
-     *             (<code>JobId</code>) that you use to get the results of the operation. When text
-     *          analysis is finished, Amazon Textract publishes a completion status to the Amazon Simple Notification Service (Amazon SNS)
-     *          topic that you specify in <code>NotificationChannel</code>. To get the results of the text
-     *          analysis operation, first check that the status value published to the Amazon SNS topic is
-     *             <code>SUCCEEDED</code>. If so, call <a>GetDocumentAnalysis</a>, and pass
-     *          the job identifier (<code>JobId</code>) from the initial call to
-     *             <code>StartDocumentAnalysis</code>.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html">Document Text Analysis</a>.</p>
-     */
+    
     startDocumentAnalysis(args: StartDocumentAnalysisCommandInput, options?: __HttpHandlerOptions): Promise<StartDocumentAnalysisCommandOutput>;
     startDocumentAnalysis(args: StartDocumentAnalysisCommandInput, cb: (err: any, data?: StartDocumentAnalysisCommandOutput) => void): void;
     startDocumentAnalysis(args: StartDocumentAnalysisCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartDocumentAnalysisCommandOutput) => void): void;
-    /**
-     * <p>Starts the asynchronous detection of text in a document. Amazon Textract can detect lines of
-     *          text and the words that make up a line of text.</p>
-     *          <p>
-     *             <code>StartDocumentTextDetection</code> can analyze text in documents that are in JPEG, PNG, and PDF format. The
-     *         documents are stored in an Amazon S3 bucket. Use <a>DocumentLocation</a> to specify the bucket name and file name
-     *         of the document.
-     *      </p>
-     *          <p>
-     *             <code>StartTextDetection</code> returns a job identifier
-     *             (<code>JobId</code>) that you use to get the results of the operation. When text
-     *          detection is finished, Amazon Textract publishes a completion status to the Amazon Simple Notification Service (Amazon SNS)
-     *          topic that you specify in <code>NotificationChannel</code>. To get the results of the text
-     *          detection operation, first check that the status value published to the Amazon SNS topic is
-     *             <code>SUCCEEDED</code>. If so, call <a>GetDocumentTextDetection</a>, and
-     *          pass the job identifier (<code>JobId</code>) from the initial call to
-     *             <code>StartDocumentTextDetection</code>.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html">Document Text Detection</a>.</p>
-     */
+    
     startDocumentTextDetection(args: StartDocumentTextDetectionCommandInput, options?: __HttpHandlerOptions): Promise<StartDocumentTextDetectionCommandOutput>;
     startDocumentTextDetection(args: StartDocumentTextDetectionCommandInput, cb: (err: any, data?: StartDocumentTextDetectionCommandOutput) => void): void;
     startDocumentTextDetection(args: StartDocumentTextDetectionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartDocumentTextDetectionCommandOutput) => void): void;

package/dist-types/ts3.4/TextractClient.d.ts

@@ -16,126 +16,59 @@ import { StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionComma
 export declare type ServiceInputTypes = AnalyzeDocumentCommandInput | AnalyzeExpenseCommandInput | DetectDocumentTextCommandInput | GetDocumentAnalysisCommandInput | GetDocumentTextDetectionCommandInput | StartDocumentAnalysisCommandInput | StartDocumentTextDetectionCommandInput;
 export declare type ServiceOutputTypes = AnalyzeDocumentCommandOutput | AnalyzeExpenseCommandOutput | DetectDocumentTextCommandOutput | GetDocumentAnalysisCommandOutput | GetDocumentTextDetectionCommandOutput | StartDocumentAnalysisCommandOutput | StartDocumentTextDetectionCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type TextractClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of TextractClient class constructor that set the region, credentials and other options.
- */
+
 export interface TextractClientConfig extends TextractClientConfigType {
 }
 declare type TextractClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of TextractClient class. This is resolved and normalized from the {@link TextractClientConfig | constructor configuration interface}.
- */
+
 export interface TextractClientResolvedConfig extends TextractClientResolvedConfigType {
 }
-/**
- * <p>Amazon Textract detects and analyzes text in documents and converts it
- *          into machine-readable text. This is the API reference documentation for
- *          Amazon Textract.</p>
- */
+
 export declare class TextractClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig> {
-    /**
-     * The resolved configuration of TextractClient class. This is resolved and normalized from the {@link TextractClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: TextractClientResolvedConfig;
     constructor(configuration: TextractClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,59 +6,11 @@ export interface AnalyzeDocumentCommandInput extends AnalyzeDocumentRequest {
 }
 export interface AnalyzeDocumentCommandOutput extends AnalyzeDocumentResponse, __MetadataBearer {
 }
-/**
- * <p>Analyzes an input document for relationships between detected items.  </p>
- *          <p>The types of information returned are as follows: </p>
- *          <ul>
- *             <li>
- *                <p>Form data (key-value pairs). The related information is returned in two <a>Block</a> objects, each of type <code>KEY_VALUE_SET</code>: a KEY
- *                   <code>Block</code> object and a VALUE <code>Block</code> object. For example,
- *                   <i>Name: Ana Silva Carolina</i> contains a key and value.
- *                   <i>Name:</i> is the key. <i>Ana Silva Carolina</i> is
- *                the value.</p>
- *             </li>
- *             <li>
- *                <p>Table and table cell data. A TABLE <code>Block</code> object contains information about a detected table. A CELL
- *                <code>Block</code> object is returned for each cell in a table.</p>
- *             </li>
- *             <li>
- *                <p>Lines and words of text. A LINE <code>Block</code> object contains one or more WORD <code>Block</code> objects.
- *         All lines and words that are detected in the document are returned (including text that doesn't have a
- *                relationship with the value of <code>FeatureTypes</code>). </p>
- *             </li>
- *          </ul>
- *
- *          <p>Selection elements such as check boxes and option buttons (radio buttons) can be detected in form data and in tables.
- *          A SELECTION_ELEMENT <code>Block</code> object contains information about a selection element,
- *          including the selection status.</p>
- *          <p>You can choose which type of analysis to perform by specifying the <code>FeatureTypes</code> list.
- *       </p>
- *          <p>The output is returned in a list of <code>Block</code> objects.</p>
- *          <p>
- *             <code>AnalyzeDocument</code> is a synchronous operation. To analyze documents
- *       asynchronously, use <a>StartDocumentAnalysis</a>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html">Document Text Analysis</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, AnalyzeDocumentCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, AnalyzeDocumentCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new AnalyzeDocumentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AnalyzeDocumentCommandInput} for command's `input` shape.
- * @see {@link AnalyzeDocumentCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AnalyzeDocumentCommand extends $Command<AnalyzeDocumentCommandInput, AnalyzeDocumentCommandOutput, TextractClientResolvedConfig> {
     readonly input: AnalyzeDocumentCommandInput;
     constructor(input: AnalyzeDocumentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AnalyzeDocumentCommandInput, AnalyzeDocumentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface AnalyzeExpenseCommandInput extends AnalyzeExpenseRequest {
 }
 export interface AnalyzeExpenseCommandOutput extends AnalyzeExpenseResponse, __MetadataBearer {
 }
-/**
- * <p>Analyzes an input document for financially related relationships between text.</p>
- *          <p>Information is returned as <code>ExpenseDocuments</code> and seperated as follows.</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>LineItemGroups</code>- A data set containing <code>LineItems</code> which
- *          store information about the lines of text, such as an item purchased and its price on a receipt.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>SummaryFields</code>- Contains all other information a receipt, such as header information
- *          or the vendors name.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, AnalyzeExpenseCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, AnalyzeExpenseCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new AnalyzeExpenseCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AnalyzeExpenseCommandInput} for command's `input` shape.
- * @see {@link AnalyzeExpenseCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AnalyzeExpenseCommand extends $Command<AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput, TextractClientResolvedConfig> {
     readonly input: AnalyzeExpenseCommandInput;
     constructor(input: AnalyzeExpenseCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface DetectDocumentTextCommandInput extends DetectDocumentTextReques
 }
 export interface DetectDocumentTextCommandOutput extends DetectDocumentTextResponse, __MetadataBearer {
 }
-/**
- * <p>Detects text in the input document. Amazon Textract can detect lines of text and the
- *          words that make up a line of text. The input document must be an image in JPEG or PNG
- *          format. <code>DetectDocumentText</code> returns the detected text in an array of <a>Block</a> objects. </p>
- *          <p>Each document page has as an associated <code>Block</code> of type PAGE. Each PAGE <code>Block</code> object
- *          is the parent of LINE <code>Block</code> objects that represent the lines of detected text on a page. A LINE <code>Block</code> object is
- *          a parent for each word that makes up the line. Words are represented by <code>Block</code> objects of type WORD.</p>
- *
- *          <p>
- *             <code>DetectDocumentText</code> is a synchronous operation. To analyze documents
- *          asynchronously, use <a>StartDocumentTextDetection</a>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html">Document Text Detection</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, DetectDocumentTextCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, DetectDocumentTextCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new DetectDocumentTextCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectDocumentTextCommandInput} for command's `input` shape.
- * @see {@link DetectDocumentTextCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectDocumentTextCommand extends $Command<DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput, TextractClientResolvedConfig> {
     readonly input: DetectDocumentTextCommandInput;
     constructor(input: DetectDocumentTextCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,73 +6,11 @@ export interface GetDocumentAnalysisCommandInput extends GetDocumentAnalysisRequ
 }
 export interface GetDocumentAnalysisCommandOutput extends GetDocumentAnalysisResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the results for an Amazon Textract asynchronous operation that analyzes text in a document.</p>
- *          <p>You start asynchronous text analysis by calling <a>StartDocumentAnalysis</a>, which returns a job identifier
- *             (<code>JobId</code>). When the text analysis operation finishes, Amazon Textract publishes a
- *          completion status to the Amazon Simple Notification Service (Amazon SNS) topic that's registered in the initial call to
- *             <code>StartDocumentAnalysis</code>. To get the results of the text-detection operation,
- *          first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
- *          If so, call <code>GetDocumentAnalysis</code>, and pass the job identifier
- *             (<code>JobId</code>) from the initial call to <code>StartDocumentAnalysis</code>.</p>
- *          <p>
- *             <code>GetDocumentAnalysis</code> returns an array of <a>Block</a> objects. The following
- *          types of information are returned: </p>
- *          <ul>
- *             <li>
- *                <p>Form data (key-value pairs). The related information is returned in two <a>Block</a> objects, each of type <code>KEY_VALUE_SET</code>: a KEY
- *             <code>Block</code> object and a VALUE <code>Block</code> object. For example,
- *             <i>Name: Ana Silva Carolina</i> contains a key and value.
- *             <i>Name:</i> is the key. <i>Ana Silva Carolina</i> is
- *             the value.</p>
- *             </li>
- *             <li>
- *                <p>Table and table cell data. A TABLE <code>Block</code> object contains information about a detected table. A CELL
- *             <code>Block</code> object is returned for each cell in a table.</p>
- *             </li>
- *             <li>
- *                <p>Lines and words of text. A LINE <code>Block</code> object contains one or more WORD <code>Block</code> objects.
- *             All lines and words that are detected in the document are returned (including text that doesn't have a
- *             relationship with the value of the <code>StartDocumentAnalysis</code>
- *                   <code>FeatureTypes</code> input parameter). </p>
- *             </li>
- *          </ul>
- *
- *          <p>Selection elements such as check boxes and option buttons (radio buttons) can be detected in form data and in tables.
- *          A SELECTION_ELEMENT <code>Block</code> object contains information about a selection element,
- *          including the selection status.</p>
- *
- *
- *
- *          <p>Use the <code>MaxResults</code> parameter to limit the number of blocks that are
- *          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>GetDocumentAnalysis</code>, and populate the <code>NextToken</code> request
- *          parameter with the token value that's returned from the previous call to
- *             <code>GetDocumentAnalysis</code>.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html">Document Text Analysis</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, GetDocumentAnalysisCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, GetDocumentAnalysisCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new GetDocumentAnalysisCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDocumentAnalysisCommandInput} for command's `input` shape.
- * @see {@link GetDocumentAnalysisCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDocumentAnalysisCommand extends $Command<GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput, TextractClientResolvedConfig> {
     readonly input: GetDocumentAnalysisCommandInput;
     constructor(input: GetDocumentAnalysisCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput>;
     private serialize;
     private deserialize;