@aws-sdk/client-textract 3.36.0 → 3.39.0

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

@@ -11,131 +11,66 @@ 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";
-export declare type ServiceInputTypes = AnalyzeDocumentCommandInput | AnalyzeExpenseCommandInput | DetectDocumentTextCommandInput | GetDocumentAnalysisCommandInput | GetDocumentTextDetectionCommandInput | StartDocumentAnalysisCommandInput | StartDocumentTextDetectionCommandInput;
-export declare type ServiceOutputTypes = AnalyzeDocumentCommandOutput | AnalyzeExpenseCommandOutput | DetectDocumentTextCommandOutput | GetDocumentAnalysisCommandOutput | GetDocumentTextDetectionCommandOutput | StartDocumentAnalysisCommandOutput | StartDocumentTextDetectionCommandOutput;
+import { StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput } from "./commands/StartExpenseAnalysisCommand";
+export declare type ServiceInputTypes = AnalyzeDocumentCommandInput | AnalyzeExpenseCommandInput | DetectDocumentTextCommandInput | GetDocumentAnalysisCommandInput | GetDocumentTextDetectionCommandInput | GetExpenseAnalysisCommandInput | StartDocumentAnalysisCommandInput | StartDocumentTextDetectionCommandInput | StartExpenseAnalysisCommandInput;
+export declare type ServiceOutputTypes = AnalyzeDocumentCommandOutput | AnalyzeExpenseCommandOutput | DetectDocumentTextCommandOutput | GetDocumentAnalysisCommandOutput | GetDocumentTextDetectionCommandOutput | GetExpenseAnalysisCommandOutput | StartDocumentAnalysisCommandOutput | StartDocumentTextDetectionCommandOutput | StartExpenseAnalysisCommandOutput;
 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;

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

@@ -6,53 +6,11 @@ export interface GetDocumentTextDetectionCommandInput extends GetDocumentTextDet
 }
 export interface GetDocumentTextDetectionCommandOutput extends GetDocumentTextDetectionResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, GetDocumentTextDetectionCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, GetDocumentTextDetectionCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new GetDocumentTextDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDocumentTextDetectionCommandInput} for command's `input` shape.
- * @see {@link GetDocumentTextDetectionCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDocumentTextDetectionCommand extends $Command<GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput, TextractClientResolvedConfig> {
     readonly input: GetDocumentTextDetectionCommandInput;
     constructor(input: GetDocumentTextDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetExpenseAnalysisRequest, GetExpenseAnalysisResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface GetExpenseAnalysisCommandInput extends GetExpenseAnalysisRequest {
+}
+export interface GetExpenseAnalysisCommandOutput extends GetExpenseAnalysisResponse, __MetadataBearer {
+}
+
+export declare class GetExpenseAnalysisCommand extends $Command<GetExpenseAnalysisCommandInput, GetExpenseAnalysisCommandOutput, TextractClientResolvedConfig> {
+    readonly input: GetExpenseAnalysisCommandInput;
+    constructor(input: GetExpenseAnalysisCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetExpenseAnalysisCommandInput, GetExpenseAnalysisCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -6,46 +6,11 @@ export interface StartDocumentAnalysisCommandInput extends StartDocumentAnalysis
 }
 export interface StartDocumentAnalysisCommandOutput extends StartDocumentAnalysisResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, StartDocumentAnalysisCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, StartDocumentAnalysisCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new StartDocumentAnalysisCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartDocumentAnalysisCommandInput} for command's `input` shape.
- * @see {@link StartDocumentAnalysisCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartDocumentAnalysisCommand extends $Command<StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput, TextractClientResolvedConfig> {
     readonly input: StartDocumentAnalysisCommandInput;
     constructor(input: StartDocumentAnalysisCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,45 +6,11 @@ export interface StartDocumentTextDetectionCommandInput extends StartDocumentTex
 }
 export interface StartDocumentTextDetectionCommandOutput extends StartDocumentTextDetectionResponse, __MetadataBearer {
 }
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { TextractClient, StartDocumentTextDetectionCommand } from "@aws-sdk/client-textract"; // ES Modules import
- * // const { TextractClient, StartDocumentTextDetectionCommand } = require("@aws-sdk/client-textract"); // CommonJS import
- * const client = new TextractClient(config);
- * const command = new StartDocumentTextDetectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartDocumentTextDetectionCommandInput} for command's `input` shape.
- * @see {@link StartDocumentTextDetectionCommandOutput} for command's `response` shape.
- * @see {@link TextractClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartDocumentTextDetectionCommand extends $Command<StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput, TextractClientResolvedConfig> {
     readonly input: StartDocumentTextDetectionCommandInput;
     constructor(input: StartDocumentTextDetectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,17 @@
+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 {
+}
+
+export declare class StartExpenseAnalysisCommand extends $Command<StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput, TextractClientResolvedConfig> {
+    readonly input: StartExpenseAnalysisCommandInput;
+    constructor(input: StartExpenseAnalysisCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartExpenseAnalysisCommandInput, StartExpenseAnalysisCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/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/ts3.4/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";