@aws-sdk/client-textract 3.50.0 → 3.53.0

package/dist-types/index.d.ts

@@ -2,3 +2,4 @@ export * from "./Textract";
 export * from "./TextractClient";
 export * from "./commands";
 export * from "./models";
+export { TextractServiceException } from "./models/TextractServiceException";

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

@@ -0,0 +1,10 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+/**
+ * Base exception class for all service exceptions from Textract service.
+ */
+export declare class TextractServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

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

@@ -1,14 +1,18 @@
-import { LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
-import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { ExceptionOptionType as __ExceptionOptionType, LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
+import { TextractServiceException as __BaseException } from "./TextractServiceException";
 /**
  * <p>You aren't authorized to perform the action. Use the Amazon Resource Name (ARN)
  *             of an authorized user or IAM role to perform the operation.</p>
  */
-export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
-    name: "AccessDeniedException";
-    $fault: "client";
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
 }
 /**
  * <p>The S3 bucket name and file name that identifies the document.</p>
@@ -163,12 +167,15 @@ export declare enum BlockType {
     CELL = "CELL",
     KEY_VALUE_SET = "KEY_VALUE_SET",
     LINE = "LINE",
+    MERGED_CELL = "MERGED_CELL",
     PAGE = "PAGE",
     SELECTION_ELEMENT = "SELECTION_ELEMENT",
     TABLE = "TABLE",
+    TITLE = "TITLE",
     WORD = "WORD"
 }
 export declare enum EntityType {
+    COLUMN_HEADER = "COLUMN_HEADER",
     KEY = "KEY",
     VALUE = "VALUE"
 }
@@ -265,6 +272,8 @@ export declare namespace Geometry {
 export declare enum RelationshipType {
     CHILD = "CHILD",
     COMPLEX_FEATURES = "COMPLEX_FEATURES",
+    MERGED_CELL = "MERGED_CELL",
+    TITLE = "TITLE",
     VALUE = "VALUE"
 }
 /**
@@ -555,29 +564,37 @@ export declare namespace AnalyzeDocumentResponse {
  * <p>Amazon Textract isn't able to read the document. For more information on the document
  *          limits in Amazon Textract, see <a>limits</a>.</p>
  */
-export interface BadDocumentException extends __SmithyException, $MetadataBearer {
-    name: "BadDocumentException";
-    $fault: "client";
+export declare class BadDocumentException extends __BaseException {
+    readonly name: "BadDocumentException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<BadDocumentException, __BaseException>);
 }
 /**
  * <p>The document can't be processed because it's too large. The maximum document size for
  *          synchronous operations 10 MB. The maximum document size for asynchronous operations is 500
  *          MB for PDF files.</p>
  */
-export interface DocumentTooLargeException extends __SmithyException, $MetadataBearer {
-    name: "DocumentTooLargeException";
-    $fault: "client";
+export declare class DocumentTooLargeException extends __BaseException {
+    readonly name: "DocumentTooLargeException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DocumentTooLargeException, __BaseException>);
 }
 /**
  * <p>Indicates you have exceeded the maximum number of active human in the loop workflows available</p>
  */
-export interface HumanLoopQuotaExceededException extends __SmithyException, $MetadataBearer {
-    name: "HumanLoopQuotaExceededException";
-    $fault: "client";
+export declare class HumanLoopQuotaExceededException extends __BaseException {
+    readonly name: "HumanLoopQuotaExceededException";
+    readonly $fault: "client";
     /**
      * <p>The resource type.</p>
      */
@@ -592,15 +609,23 @@ export interface HumanLoopQuotaExceededException extends __SmithyException, $Met
     ServiceCode?: string;
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<HumanLoopQuotaExceededException, __BaseException>);
 }
 /**
  * <p>Amazon Textract experienced a service issue. Try your call again.</p>
  */
-export interface InternalServerError extends __SmithyException, $MetadataBearer {
-    name: "InternalServerError";
-    $fault: "server";
+export declare class InternalServerError extends __BaseException {
+    readonly name: "InternalServerError";
+    readonly $fault: "server";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerError, __BaseException>);
 }
 /**
  * <p>An input parameter violated a constraint. For example, in synchronous operations,
@@ -609,11 +634,15 @@ export interface InternalServerError extends __SmithyException, $MetadataBearer
  *       request parameter.
  *        Validate your parameter before calling the API operation again.</p>
  */
-export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
-    name: "InvalidParameterException";
-    $fault: "client";
+export declare class InvalidParameterException extends __BaseException {
+    readonly name: "InvalidParameterException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidParameterException, __BaseException>);
 }
 /**
  * <p>Amazon Textract is unable to access the S3 object that's specified in the request.
@@ -621,40 +650,56 @@ export interface InvalidParameterException extends __SmithyException, $MetadataB
  *          For troubleshooting information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/troubleshooting.html">Troubleshooting Amazon S3</a>
  *          </p>
  */
-export interface InvalidS3ObjectException extends __SmithyException, $MetadataBearer {
-    name: "InvalidS3ObjectException";
-    $fault: "client";
+export declare class InvalidS3ObjectException extends __BaseException {
+    readonly name: "InvalidS3ObjectException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidS3ObjectException, __BaseException>);
 }
 /**
  * <p>The number of requests exceeded your throughput limit. If you want to increase this limit,
  *          contact Amazon Textract.</p>
  */
-export interface ProvisionedThroughputExceededException extends __SmithyException, $MetadataBearer {
-    name: "ProvisionedThroughputExceededException";
-    $fault: "client";
+export declare class ProvisionedThroughputExceededException extends __BaseException {
+    readonly name: "ProvisionedThroughputExceededException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ProvisionedThroughputExceededException, __BaseException>);
 }
 /**
  * <p>Amazon Textract is temporarily unable to process the request. Try your call again.</p>
  */
-export interface ThrottlingException extends __SmithyException, $MetadataBearer {
-    name: "ThrottlingException";
-    $fault: "server";
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "server";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
 }
 /**
  * <p>The format of the input document isn't supported. Documents for synchronous operations can be in
  *          PNG or JPEG format only. Documents for asynchronous operations can be in PDF format.</p>
  */
-export interface UnsupportedDocumentException extends __SmithyException, $MetadataBearer {
-    name: "UnsupportedDocumentException";
-    $fault: "client";
+export declare class UnsupportedDocumentException extends __BaseException {
+    readonly name: "UnsupportedDocumentException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UnsupportedDocumentException, __BaseException>);
 }
 export interface AnalyzeExpenseRequest {
     /**
@@ -1097,21 +1142,29 @@ export declare namespace GetDocumentAnalysisResponse {
  * <p>An invalid job identifier was passed to <a>GetDocumentAnalysis</a> or to
  *       <a>GetDocumentAnalysis</a>.</p>
  */
-export interface InvalidJobIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidJobIdException";
-    $fault: "client";
+export declare class InvalidJobIdException extends __BaseException {
+    readonly name: "InvalidJobIdException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidJobIdException, __BaseException>);
 }
 /**
  * <p> Indicates you do not have decrypt permissions with the KMS key entered, or the KMS key
  *         was entered incorrectly. </p>
  */
-export interface InvalidKMSKeyException extends __SmithyException, $MetadataBearer {
-    name: "InvalidKMSKeyException";
-    $fault: "client";
+export declare class InvalidKMSKeyException extends __BaseException {
+    readonly name: "InvalidKMSKeyException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidKMSKeyException, __BaseException>);
 }
 export interface GetDocumentTextDetectionRequest {
     /**
@@ -1244,11 +1297,15 @@ export declare namespace GetExpenseAnalysisResponse {
  *          least one of the other input parameters is different from the previous call to the
  *          operation. </p>
  */
-export interface IdempotentParameterMismatchException extends __SmithyException, $MetadataBearer {
-    name: "IdempotentParameterMismatchException";
-    $fault: "client";
+export declare class IdempotentParameterMismatchException extends __BaseException {
+    readonly name: "IdempotentParameterMismatchException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IdempotentParameterMismatchException, __BaseException>);
 }
 /**
  * <p>An Amazon Textract service limit was exceeded. For example, if you start too many
@@ -1257,11 +1314,15 @@ export interface IdempotentParameterMismatchException extends __SmithyException,
  *          exception (HTTP status code: 400) until the number of concurrently running jobs is below
  *          the Amazon Textract service limit. </p>
  */
-export interface LimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "LimitExceededException";
-    $fault: "client";
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
     Message?: string;
     Code?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
 }
 /**
  * <p>The Amazon Simple Notification Service (Amazon SNS) topic to which Amazon Textract publishes the completion status of

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

@@ -0,0 +1,55 @@
+import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+import { AnalyzeDocumentCommandInput, AnalyzeDocumentCommandOutput } from "./commands/AnalyzeDocumentCommand";
+import { AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput } from "./commands/AnalyzeExpenseCommand";
+import { AnalyzeIDCommandInput, AnalyzeIDCommandOutput } from "./commands/AnalyzeIDCommand";
+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";
+
+export declare class Textract extends TextractClient {
+    
+    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;
+    
+    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;
+    
+    analyzeID(args: AnalyzeIDCommandInput, options?: __HttpHandlerOptions): Promise<AnalyzeIDCommandOutput>;
+    analyzeID(args: AnalyzeIDCommandInput, cb: (err: any, data?: AnalyzeIDCommandOutput) => void): void;
+    analyzeID(args: AnalyzeIDCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AnalyzeIDCommandOutput) => void): void;
+    
+    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;
+    
+    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;
+    
+    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;
+    
+    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;
+    
+    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;
+}

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

@@ -0,0 +1,83 @@
+import { EndpointsInputConfig, EndpointsResolvedConfig, RegionInputConfig, RegionResolvedConfig } from "@aws-sdk/config-resolver";
+import { HostHeaderInputConfig, HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
+import { RetryInputConfig, RetryResolvedConfig } from "@aws-sdk/middleware-retry";
+import { AwsAuthInputConfig, AwsAuthResolvedConfig } from "@aws-sdk/middleware-signing";
+import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
+import { Client as __Client, DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
+import { Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
+import { AnalyzeDocumentCommandInput, AnalyzeDocumentCommandOutput } from "./commands/AnalyzeDocumentCommand";
+import { AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput } from "./commands/AnalyzeExpenseCommand";
+import { AnalyzeIDCommandInput, AnalyzeIDCommandOutput } from "./commands/AnalyzeIDCommand";
+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 type ServiceInputTypes = AnalyzeDocumentCommandInput | AnalyzeExpenseCommandInput | AnalyzeIDCommandInput | DetectDocumentTextCommandInput | GetDocumentAnalysisCommandInput | GetDocumentTextDetectionCommandInput | GetExpenseAnalysisCommandInput | StartDocumentAnalysisCommandInput | StartDocumentTextDetectionCommandInput | StartExpenseAnalysisCommandInput;
+export declare type ServiceOutputTypes = AnalyzeDocumentCommandOutput | AnalyzeExpenseCommandOutput | AnalyzeIDCommandOutput | DetectDocumentTextCommandOutput | GetDocumentAnalysisCommandOutput | GetDocumentTextDetectionCommandOutput | GetExpenseAnalysisCommandOutput | StartDocumentAnalysisCommandOutput | StartDocumentTextDetectionCommandOutput | StartExpenseAnalysisCommandOutput;
+export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
+    
+    requestHandler?: __HttpHandler;
+    
+    sha256?: __HashConstructor;
+    
+    urlParser?: __UrlParser;
+    
+    bodyLengthChecker?: (body: any) => number | undefined;
+    
+    streamCollector?: __StreamCollector;
+    
+    base64Decoder?: __Decoder;
+    
+    base64Encoder?: __Encoder;
+    
+    utf8Decoder?: __Decoder;
+    
+    utf8Encoder?: __Encoder;
+    
+    runtime?: string;
+    
+    disableHostPrefix?: boolean;
+    
+    maxAttempts?: number | __Provider<number>;
+    
+    retryMode?: string | __Provider<string>;
+    
+    logger?: __Logger;
+    
+    useDualstackEndpoint?: boolean | __Provider<boolean>;
+    
+    useFipsEndpoint?: boolean | __Provider<boolean>;
+    
+    serviceId?: string;
+    
+    region?: string | __Provider<string>;
+    
+    credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
+    
+    regionInfoProvider?: RegionInfoProvider;
+    
+    defaultUserAgentProvider?: Provider<__UserAgent>;
+    
+    defaultsMode?: DefaultsMode | Provider<DefaultsMode>;
+}
+declare type TextractClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
+
+export interface TextractClientConfig extends TextractClientConfigType {
+}
+declare type TextractClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
+
+export interface TextractClientResolvedConfig extends TextractClientResolvedConfigType {
+}
+
+export declare class TextractClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig> {
+    
+    readonly config: TextractClientResolvedConfig;
+    constructor(configuration: TextractClientConfig);
+    
+    destroy(): void;
+}
+export {};

package/dist-types/ts3.4/commands/AnalyzeDocumentCommand.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 { AnalyzeDocumentRequest, AnalyzeDocumentResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface AnalyzeDocumentCommandInput extends AnalyzeDocumentRequest {
+}
+export interface AnalyzeDocumentCommandOutput extends AnalyzeDocumentResponse, __MetadataBearer {
+}
+
+export declare class AnalyzeDocumentCommand extends $Command<AnalyzeDocumentCommandInput, AnalyzeDocumentCommandOutput, TextractClientResolvedConfig> {
+    readonly input: AnalyzeDocumentCommandInput;
+    constructor(input: AnalyzeDocumentCommandInput);
+    
+    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

@@ -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 { AnalyzeExpenseRequest, AnalyzeExpenseResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface AnalyzeExpenseCommandInput extends AnalyzeExpenseRequest {
+}
+export interface AnalyzeExpenseCommandOutput extends AnalyzeExpenseResponse, __MetadataBearer {
+}
+
+export declare class AnalyzeExpenseCommand extends $Command<AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput, TextractClientResolvedConfig> {
+    readonly input: AnalyzeExpenseCommandInput;
+    constructor(input: AnalyzeExpenseCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/AnalyzeIDCommand.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 { AnalyzeIDRequest, AnalyzeIDResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface AnalyzeIDCommandInput extends AnalyzeIDRequest {
+}
+export interface AnalyzeIDCommandOutput extends AnalyzeIDResponse, __MetadataBearer {
+}
+
+export declare class AnalyzeIDCommand extends $Command<AnalyzeIDCommandInput, AnalyzeIDCommandOutput, TextractClientResolvedConfig> {
+    readonly input: AnalyzeIDCommandInput;
+    constructor(input: AnalyzeIDCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TextractClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AnalyzeIDCommandInput, AnalyzeIDCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/DetectDocumentTextCommand.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 { DetectDocumentTextRequest, DetectDocumentTextResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface DetectDocumentTextCommandInput extends DetectDocumentTextRequest {
+}
+export interface DetectDocumentTextCommandOutput extends DetectDocumentTextResponse, __MetadataBearer {
+}
+
+export declare class DetectDocumentTextCommand extends $Command<DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput, TextractClientResolvedConfig> {
+    readonly input: DetectDocumentTextCommandInput;
+    constructor(input: DetectDocumentTextCommandInput);
+    
+    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

@@ -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 { GetDocumentAnalysisRequest, GetDocumentAnalysisResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface GetDocumentAnalysisCommandInput extends GetDocumentAnalysisRequest {
+}
+export interface GetDocumentAnalysisCommandOutput extends GetDocumentAnalysisResponse, __MetadataBearer {
+}
+
+export declare class GetDocumentAnalysisCommand extends $Command<GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput, TextractClientResolvedConfig> {
+    readonly input: GetDocumentAnalysisCommandInput;
+    constructor(input: GetDocumentAnalysisCommandInput);
+    
+    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

@@ -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 { GetDocumentTextDetectionRequest, GetDocumentTextDetectionResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface GetDocumentTextDetectionCommandInput extends GetDocumentTextDetectionRequest {
+}
+export interface GetDocumentTextDetectionCommandOutput extends GetDocumentTextDetectionResponse, __MetadataBearer {
+}
+
+export declare class GetDocumentTextDetectionCommand extends $Command<GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput, TextractClientResolvedConfig> {
+    readonly input: GetDocumentTextDetectionCommandInput;
+    constructor(input: GetDocumentTextDetectionCommandInput);
+    
+    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

@@ -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 { StartDocumentAnalysisRequest, StartDocumentAnalysisResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface StartDocumentAnalysisCommandInput extends StartDocumentAnalysisRequest {
+}
+export interface StartDocumentAnalysisCommandOutput extends StartDocumentAnalysisResponse, __MetadataBearer {
+}
+
+export declare class StartDocumentAnalysisCommand extends $Command<StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput, TextractClientResolvedConfig> {
+    readonly input: StartDocumentAnalysisCommandInput;
+    constructor(input: StartDocumentAnalysisCommandInput);
+    
+    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

@@ -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 { StartDocumentTextDetectionRequest, StartDocumentTextDetectionResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TextractClientResolvedConfig } from "../TextractClient";
+export interface StartDocumentTextDetectionCommandInput extends StartDocumentTextDetectionRequest {
+}
+export interface StartDocumentTextDetectionCommandOutput extends StartDocumentTextDetectionResponse, __MetadataBearer {
+}
+
+export declare class StartDocumentTextDetectionCommand extends $Command<StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput, TextractClientResolvedConfig> {
+    readonly input: StartDocumentTextDetectionCommandInput;
+    constructor(input: StartDocumentTextDetectionCommandInput);
+    
+    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,10 @@
+export * from "./AnalyzeDocumentCommand";
+export * from "./AnalyzeExpenseCommand";
+export * from "./AnalyzeIDCommand";
+export * from "./DetectDocumentTextCommand";
+export * from "./GetDocumentAnalysisCommand";
+export * from "./GetDocumentTextDetectionCommand";
+export * from "./GetExpenseAnalysisCommand";
+export * from "./StartDocumentAnalysisCommand";
+export * from "./StartDocumentTextDetectionCommand";
+export * from "./StartExpenseAnalysisCommand";