@aws-sdk/client-textract 3.36.0 → 3.39.0

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

@@ -11,7 +11,7 @@ export interface StartDocumentAnalysisCommandOutput extends StartDocumentAnalysi
  *          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
+ *             <code>StartDocumentAnalysis</code> can analyze text in documents that are in JPEG, PNG, TIFF, 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>

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

@@ -10,7 +10,7 @@ export interface StartDocumentTextDetectionCommandOutput extends StartDocumentTe
  * <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
+ *             <code>StartDocumentTextDetection</code> can analyze text in documents that are in JPEG, PNG, TIFF, 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>

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

@@ -0,0 +1,50 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { StartExpenseAnalysisRequest, StartExpenseAnalysisResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface StartExpenseAnalysisCommandInput extends StartExpenseAnalysisRequest {
+}
+export interface StartExpenseAnalysisCommandOutput extends StartExpenseAnalysisResponse, __MetadataBearer {
+}
+/**
+ * <p>Starts the asynchronous analysis of invoices or receipts for data like contact information,
+ *    items purchased, and vendor names.</p>
+ *
+ *          <p>
+ *             <code>StartExpenseAnalysis</code> can analyze text in documents that are in JPEG, PNG, and
+ *    PDF format. The documents must be stored in an Amazon S3 bucket. Use the <a>DocumentLocation</a> parameter to specify the name of your S3 bucket and the name of the
+ *    document in that bucket. </p>
+ *          <p>
+ *             <code>StartExpenseAnalysis</code> returns a job identifier (<code>JobId</code>) that you
+ *    will provide to <code>GetExpenseAnalysis</code> to retrieve the results of the operation. When
+ *    the analysis of the input invoices/receipts is finished, Amazon Textract publishes a completion
+ *    status to the Amazon Simple Notification Service (Amazon SNS) topic that you provide to the <code>NotificationChannel</code>.
+ *    To obtain the results of the invoice and receipt analysis operation, ensure that the status value
+ *    published to the Amazon SNS topic is <code>SUCCEEDED</code>. If so, call <a>GetExpenseAnalysis</a>, and pass the job identifier (<code>JobId</code>) that was
+ *    returned by your call to <code>StartExpenseAnalysis</code>.</p>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/invoice-receipts.html">Analyzing Invoices and Receipts</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TextractClient, StartExpenseAnalysisCommand } from "@aws-sdk/client-textract"; // ES Modules import
+ * // const { TextractClient, StartExpenseAnalysisCommand } = require("@aws-sdk/client-textract"); // CommonJS import
+ * const client = new TextractClient(config);
+ * const command = new StartExpenseAnalysisCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartExpenseAnalysisCommandInput} for command's `input` shape.
+ * @see {@link StartExpenseAnalysisCommandOutput} for command's `response` shape.
+ * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StartExpenseAnalysisCommand extends $Command<StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput, TextractClientResolvedConfig> {
+    readonly input: StartExpenseAnalysisCommandInput;
+    constructor(input: StartExpenseAnalysisCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,9 @@
+export * from "./AnalyzeDocumentCommand";
+export * from "./AnalyzeExpenseCommand";
+export * from "./DetectDocumentTextCommand";
+export * from "./GetDocumentAnalysisCommand";
+export * from "./GetDocumentTextDetectionCommand";
+export * from "./GetExpenseAnalysisCommand";
+export * from "./StartDocumentAnalysisCommand";
+export * from "./StartDocumentTextDetectionCommand";
+export * from "./StartExpenseAnalysisCommand";

package/dist-types/index.d.ts

@@ -1,10 +1,4 @@
-export * from "./TextractClient";
 export * from "./Textract";
-export * from "./commands/AnalyzeDocumentCommand";
-export * from "./commands/AnalyzeExpenseCommand";
-export * from "./commands/DetectDocumentTextCommand";
-export * from "./commands/GetDocumentAnalysisCommand";
-export * from "./commands/GetDocumentTextDetectionCommand";
-export * from "./commands/StartDocumentAnalysisCommand";
-export * from "./commands/StartDocumentTextDetectionCommand";
-export * from "./models/index";
+export * from "./TextractClient";
+export * from "./commands";
+export * from "./models";

package/dist-types/models/models_0.d.ts

@@ -34,7 +34,7 @@ export interface S3Object {
     Bucket?: string;
     /**
      * <p>The file name of the input document. Synchronous operations can use image files that are
-     *          in JPEG or PNG format. Asynchronous operations also support PDF format files.</p>
+     *          in JPEG or PNG format. Asynchronous operations also support PDF and TIFF format files.</p>
      */
     Name?: string;
     /**
@@ -480,7 +480,7 @@ export interface Block {
     /**
      * <p>The page on which a block was detected. <code>Page</code> is returned by asynchronous
      *          operations. Page values greater than 1 are only returned for multipage documents that are
-     *          in PDF format. A scanned image (JPEG/PNG), even if it contains multiple document pages, is
+     *          in PDF or TIFF format. A scanned image (JPEG/PNG), even if it contains multiple document pages, is
      *          considered to be a single-page document. The value of <code>Page</code> is always 1.
      *          Synchronous operations don't return <code>Page</code> because every input document is
      *          considered to be a single-page document.</p>
@@ -1127,6 +1127,69 @@ export declare namespace GetDocumentTextDetectionResponse {
      */
     const filterSensitiveLog: (obj: GetDocumentTextDetectionResponse) => any;
 }
+export interface GetExpenseAnalysisRequest {
+    /**
+     * <p>A unique identifier for the text detection job. The <code>JobId</code> is returned from
+     *     <code>StartExpenseAnalysis</code>. A <code>JobId</code> value is only valid for 7 days.</p>
+     */
+    JobId: string | undefined;
+    /**
+     * <p>The maximum number of results to return per paginated call. The largest value you can
+     *    specify is 20. If you specify a value greater than 20, a maximum of 20 results is
+     *    returned. The default value is 20.</p>
+     */
+    MaxResults?: number;
+    /**
+     * <p>If the previous response was incomplete (because there are more blocks to retrieve), Amazon Textract returns a pagination
+     *    token in the response. You can use this pagination token to retrieve the next set of blocks.</p>
+     */
+    NextToken?: string;
+}
+export declare namespace GetExpenseAnalysisRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetExpenseAnalysisRequest) => any;
+}
+export interface GetExpenseAnalysisResponse {
+    /**
+     * <p>Information about a document that Amazon Textract processed. <code>DocumentMetadata</code> is
+     *    returned in every page of paginated responses from an Amazon Textract operation.</p>
+     */
+    DocumentMetadata?: DocumentMetadata;
+    /**
+     * <p>The current status of the text detection job.</p>
+     */
+    JobStatus?: JobStatus | string;
+    /**
+     * <p>If the response is truncated, Amazon Textract returns this token. You can use this token in
+     *    the subsequent request to retrieve the next set of text-detection results.</p>
+     */
+    NextToken?: string;
+    /**
+     * <p>The expenses detected by Amazon Textract.</p>
+     */
+    ExpenseDocuments?: ExpenseDocument[];
+    /**
+     * <p>A list of warnings that occurred during the text-detection operation for the
+     *    document.</p>
+     */
+    Warnings?: Warning[];
+    /**
+     * <p>Returns if the detection job could not be completed. Contains explanation for what error occured. </p>
+     */
+    StatusMessage?: string;
+    /**
+     * <p>The current model version of AnalyzeExpense.</p>
+     */
+    AnalyzeExpenseModelVersion?: string;
+}
+export declare namespace GetExpenseAnalysisResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetExpenseAnalysisResponse) => any;
+}
 /**
  * <p>A <code>ClientRequestToken</code> input parameter was reused with an operation, but at
  *          least one of the other input parameters is different from the previous call to the
@@ -1345,3 +1408,61 @@ export declare namespace StartDocumentTextDetectionResponse {
      */
     const filterSensitiveLog: (obj: StartDocumentTextDetectionResponse) => any;
 }
+export interface StartExpenseAnalysisRequest {
+    /**
+     * <p>The location of the document to be processed.</p>
+     */
+    DocumentLocation: DocumentLocation | undefined;
+    /**
+     * <p>The idempotent token that's used to identify the start request. If you use the same token with multiple <code>StartDocumentTextDetection</code> requests, the same <code>JobId</code> is returned.
+     *    Use <code>ClientRequestToken</code> to prevent the same job from being accidentally started more than once.
+     *    For more information, see <a href="https://docs.aws.amazon.com/textract/latest/dg/api-async.html">Calling Amazon Textract Asynchronous Operations</a>
+     *          </p>
+     */
+    ClientRequestToken?: string;
+    /**
+     * <p>An identifier you specify that's included in the completion notification published
+     *    to the Amazon SNS topic. For example, you can use <code>JobTag</code> to identify the type of
+     *    document that the completion notification corresponds to (such as a tax form or a
+     *    receipt).</p>
+     */
+    JobTag?: string;
+    /**
+     * <p>The Amazon SNS topic ARN that you want Amazon Textract to publish the completion status of the
+     *    operation to. </p>
+     */
+    NotificationChannel?: NotificationChannel;
+    /**
+     * <p>Sets if the output will go to a customer defined bucket. By default, Amazon Textract will
+     *    save the results internally to be accessed by the <code>GetExpenseAnalysis</code>
+     *    operation.</p>
+     */
+    OutputConfig?: OutputConfig;
+    /**
+     * <p>The KMS key used to encrypt the inference results. This can be
+     *    in either Key ID or Key Alias format. When a KMS key is provided, the
+     *    KMS key will be used for server-side encryption of the objects in the
+     *    customer bucket. When this parameter is not enabled, the result will
+     *    be encrypted server side,using SSE-S3.</p>
+     */
+    KMSKeyId?: string;
+}
+export declare namespace StartExpenseAnalysisRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartExpenseAnalysisRequest) => any;
+}
+export interface StartExpenseAnalysisResponse {
+    /**
+     * <p>A unique identifier for the text detection job. The <code>JobId</code> is returned from
+     *     <code>StartExpenseAnalysis</code>. A <code>JobId</code> value is only valid for 7 days.</p>
+     */
+    JobId?: string;
+}
+export declare namespace StartExpenseAnalysisResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartExpenseAnalysisResponse) => any;
+}

package/dist-types/protocols/Aws_json1_1.d.ts

@@ -5,19 +5,25 @@ import { AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput } from "../comm
 import { DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput } from "../commands/DetectDocumentTextCommand";
 import { GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput } from "../commands/GetDocumentAnalysisCommand";
 import { GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput } from "../commands/GetDocumentTextDetectionCommand";
+import { GetExpenseAnalysisCommandInput, GetExpenseAnalysisCommandOutput } from "../commands/GetExpenseAnalysisCommand";
 import { StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput } from "../commands/StartDocumentAnalysisCommand";
 import { StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput } from "../commands/StartDocumentTextDetectionCommand";
+import { StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput } from "../commands/StartExpenseAnalysisCommand";
 export declare const serializeAws_json1_1AnalyzeDocumentCommand: (input: AnalyzeDocumentCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_json1_1AnalyzeExpenseCommand: (input: AnalyzeExpenseCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_json1_1DetectDocumentTextCommand: (input: DetectDocumentTextCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_json1_1GetDocumentAnalysisCommand: (input: GetDocumentAnalysisCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_json1_1GetDocumentTextDetectionCommand: (input: GetDocumentTextDetectionCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1GetExpenseAnalysisCommand: (input: GetExpenseAnalysisCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_json1_1StartDocumentAnalysisCommand: (input: StartDocumentAnalysisCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_json1_1StartDocumentTextDetectionCommand: (input: StartDocumentTextDetectionCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_json1_1StartExpenseAnalysisCommand: (input: StartExpenseAnalysisCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const deserializeAws_json1_1AnalyzeDocumentCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<AnalyzeDocumentCommandOutput>;
 export declare const deserializeAws_json1_1AnalyzeExpenseCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<AnalyzeExpenseCommandOutput>;
 export declare const deserializeAws_json1_1DetectDocumentTextCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<DetectDocumentTextCommandOutput>;
 export declare const deserializeAws_json1_1GetDocumentAnalysisCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetDocumentAnalysisCommandOutput>;
 export declare const deserializeAws_json1_1GetDocumentTextDetectionCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetDocumentTextDetectionCommandOutput>;
+export declare const deserializeAws_json1_1GetExpenseAnalysisCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetExpenseAnalysisCommandOutput>;
 export declare const deserializeAws_json1_1StartDocumentAnalysisCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<StartDocumentAnalysisCommandOutput>;
 export declare const deserializeAws_json1_1StartDocumentTextDetectionCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<StartDocumentTextDetectionCommandOutput>;
+export declare const deserializeAws_json1_1StartExpenseAnalysisCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<StartExpenseAnalysisCommandOutput>;

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

@@ -4,209 +4,47 @@ import { AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput } from "./comma
 import { DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput } from "./commands/DetectDocumentTextCommand";
 import { GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput } from "./commands/GetDocumentAnalysisCommand";
 import { GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput } from "./commands/GetDocumentTextDetectionCommand";
+import { GetExpenseAnalysisCommandInput, GetExpenseAnalysisCommandOutput } from "./commands/GetExpenseAnalysisCommand";
 import { StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput } from "./commands/StartDocumentAnalysisCommand";
 import { StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput } from "./commands/StartDocumentTextDetectionCommand";
+import { StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput } from "./commands/StartExpenseAnalysisCommand";
 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>
-     */
+    
+    getExpenseAnalysis(args: GetExpenseAnalysisCommandInput, options?: __HttpHandlerOptions): Promise<GetExpenseAnalysisCommandOutput>;
+    getExpenseAnalysis(args: GetExpenseAnalysisCommandInput, cb: (err: any, data?: GetExpenseAnalysisCommandOutput) => void): void;
+    getExpenseAnalysis(args: GetExpenseAnalysisCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetExpenseAnalysisCommandOutput) => void): void;
+    
     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;
+    
+    startExpenseAnalysis(args: StartExpenseAnalysisCommandInput, options?: __HttpHandlerOptions): Promise<StartExpenseAnalysisCommandOutput>;
+    startExpenseAnalysis(args: StartExpenseAnalysisCommandInput, cb: (err: any, data?: StartExpenseAnalysisCommandOutput) => void): void;
+    startExpenseAnalysis(args: StartExpenseAnalysisCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartExpenseAnalysisCommandOutput) => void): void;
 }