@aws-sdk/client-textract 3.33.0 → 3.36.1

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

@@ -1,212 +0,0 @@
-import { TextractClient } from "./TextractClient";
-import { AnalyzeDocumentCommandInput, AnalyzeDocumentCommandOutput } from "./commands/AnalyzeDocumentCommand";
-import { AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput } from "./commands/AnalyzeExpenseCommand";
-import { DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput } from "./commands/DetectDocumentTextCommand";
-import { GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput } from "./commands/GetDocumentAnalysisCommand";
-import { GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput } from "./commands/GetDocumentTextDetectionCommand";
-import { StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput } from "./commands/StartDocumentAnalysisCommand";
-import { StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput } from "./commands/StartDocumentTextDetectionCommand";
-import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
-/**
- * <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/commands/AnalyzeDocumentCommand.d.ts

@@ -1,65 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-import { AnalyzeDocumentRequest, AnalyzeDocumentResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,48 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-import { AnalyzeExpenseRequest, AnalyzeExpenseResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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

@@ -1,45 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-import { DetectDocumentTextRequest, DetectDocumentTextResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DetectDocumentTextCommandInput extends DetectDocumentTextRequest {
-}
-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

@@ -1,79 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-import { GetDocumentAnalysisRequest, GetDocumentAnalysisResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetDocumentAnalysisCommandInput extends GetDocumentAnalysisRequest {
-}
-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

@@ -1,59 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-import { GetDocumentTextDetectionRequest, GetDocumentTextDetectionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetDocumentTextDetectionCommandInput extends GetDocumentTextDetectionRequest {
-}
-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/StartDocumentAnalysisCommand.d.ts

@@ -1,52 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-import { StartDocumentAnalysisRequest, StartDocumentAnalysisResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartDocumentAnalysisCommandInput extends StartDocumentAnalysisRequest {
-}
-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

@@ -1,51 +0,0 @@
-import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
-import { StartDocumentTextDetectionRequest, StartDocumentTextDetectionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartDocumentTextDetectionCommandInput extends StartDocumentTextDetectionRequest {
-}
-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;
-}