@aws-sdk/client-textract 3.33.0 → 3.36.1

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

@@ -0,0 +1,649 @@
+import { LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace AccessDeniedException {
+    
+    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+}
+
+export interface S3Object {
+    
+    Bucket?: string;
+    
+    Name?: string;
+    
+    Version?: string;
+}
+export declare namespace S3Object {
+    
+    const filterSensitiveLog: (obj: S3Object) => any;
+}
+
+export interface Document {
+    
+    Bytes?: Uint8Array;
+    
+    S3Object?: S3Object;
+}
+export declare namespace Document {
+    
+    const filterSensitiveLog: (obj: Document) => any;
+}
+export declare enum FeatureType {
+    FORMS = "FORMS",
+    TABLES = "TABLES"
+}
+export declare enum ContentClassifier {
+    FREE_OF_ADULT_CONTENT = "FreeOfAdultContent",
+    FREE_OF_PERSONALLY_IDENTIFIABLE_INFORMATION = "FreeOfPersonallyIdentifiableInformation"
+}
+
+export interface HumanLoopDataAttributes {
+    
+    ContentClassifiers?: (ContentClassifier | string)[];
+}
+export declare namespace HumanLoopDataAttributes {
+    
+    const filterSensitiveLog: (obj: HumanLoopDataAttributes) => any;
+}
+
+export interface HumanLoopConfig {
+    
+    HumanLoopName: string | undefined;
+    
+    FlowDefinitionArn: string | undefined;
+    
+    DataAttributes?: HumanLoopDataAttributes;
+}
+export declare namespace HumanLoopConfig {
+    
+    const filterSensitiveLog: (obj: HumanLoopConfig) => any;
+}
+export interface AnalyzeDocumentRequest {
+    
+    Document: Document | undefined;
+    
+    FeatureTypes: (FeatureType | string)[] | undefined;
+    
+    HumanLoopConfig?: HumanLoopConfig;
+}
+export declare namespace AnalyzeDocumentRequest {
+    
+    const filterSensitiveLog: (obj: AnalyzeDocumentRequest) => any;
+}
+export declare enum BlockType {
+    CELL = "CELL",
+    KEY_VALUE_SET = "KEY_VALUE_SET",
+    LINE = "LINE",
+    PAGE = "PAGE",
+    SELECTION_ELEMENT = "SELECTION_ELEMENT",
+    TABLE = "TABLE",
+    WORD = "WORD"
+}
+export declare enum EntityType {
+    KEY = "KEY",
+    VALUE = "VALUE"
+}
+
+export interface BoundingBox {
+    
+    Width?: number;
+    
+    Height?: number;
+    
+    Left?: number;
+    
+    Top?: number;
+}
+export declare namespace BoundingBox {
+    
+    const filterSensitiveLog: (obj: BoundingBox) => any;
+}
+
+export interface Point {
+    
+    X?: number;
+    
+    Y?: number;
+}
+export declare namespace Point {
+    
+    const filterSensitiveLog: (obj: Point) => any;
+}
+
+export interface Geometry {
+    
+    BoundingBox?: BoundingBox;
+    
+    Polygon?: Point[];
+}
+export declare namespace Geometry {
+    
+    const filterSensitiveLog: (obj: Geometry) => any;
+}
+export declare enum RelationshipType {
+    CHILD = "CHILD",
+    COMPLEX_FEATURES = "COMPLEX_FEATURES",
+    VALUE = "VALUE"
+}
+
+export interface Relationship {
+    
+    Type?: RelationshipType | string;
+    
+    Ids?: string[];
+}
+export declare namespace Relationship {
+    
+    const filterSensitiveLog: (obj: Relationship) => any;
+}
+export declare enum SelectionStatus {
+    NOT_SELECTED = "NOT_SELECTED",
+    SELECTED = "SELECTED"
+}
+export declare enum TextType {
+    HANDWRITING = "HANDWRITING",
+    PRINTED = "PRINTED"
+}
+
+export interface Block {
+    
+    BlockType?: BlockType | string;
+    
+    Confidence?: number;
+    
+    Text?: string;
+    
+    TextType?: TextType | string;
+    
+    RowIndex?: number;
+    
+    ColumnIndex?: number;
+    
+    RowSpan?: number;
+    
+    ColumnSpan?: number;
+    
+    Geometry?: Geometry;
+    
+    Id?: string;
+    
+    Relationships?: Relationship[];
+    
+    EntityTypes?: (EntityType | string)[];
+    
+    SelectionStatus?: SelectionStatus | string;
+    
+    Page?: number;
+}
+export declare namespace Block {
+    
+    const filterSensitiveLog: (obj: Block) => any;
+}
+
+export interface DocumentMetadata {
+    
+    Pages?: number;
+}
+export declare namespace DocumentMetadata {
+    
+    const filterSensitiveLog: (obj: DocumentMetadata) => any;
+}
+
+export interface HumanLoopActivationOutput {
+    
+    HumanLoopArn?: string;
+    
+    HumanLoopActivationReasons?: string[];
+    
+    HumanLoopActivationConditionsEvaluationResults?: __LazyJsonString | string;
+}
+export declare namespace HumanLoopActivationOutput {
+    
+    const filterSensitiveLog: (obj: HumanLoopActivationOutput) => any;
+}
+export interface AnalyzeDocumentResponse {
+    
+    DocumentMetadata?: DocumentMetadata;
+    
+    Blocks?: Block[];
+    
+    HumanLoopActivationOutput?: HumanLoopActivationOutput;
+    
+    AnalyzeDocumentModelVersion?: string;
+}
+export declare namespace AnalyzeDocumentResponse {
+    
+    const filterSensitiveLog: (obj: AnalyzeDocumentResponse) => any;
+}
+
+export interface BadDocumentException extends __SmithyException, $MetadataBearer {
+    name: "BadDocumentException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace BadDocumentException {
+    
+    const filterSensitiveLog: (obj: BadDocumentException) => any;
+}
+
+export interface DocumentTooLargeException extends __SmithyException, $MetadataBearer {
+    name: "DocumentTooLargeException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace DocumentTooLargeException {
+    
+    const filterSensitiveLog: (obj: DocumentTooLargeException) => any;
+}
+
+export interface HumanLoopQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "HumanLoopQuotaExceededException";
+    $fault: "client";
+    
+    ResourceType?: string;
+    
+    QuotaCode?: string;
+    
+    ServiceCode?: string;
+    Message?: string;
+    Code?: string;
+}
+export declare namespace HumanLoopQuotaExceededException {
+    
+    const filterSensitiveLog: (obj: HumanLoopQuotaExceededException) => any;
+}
+
+export interface InternalServerError extends __SmithyException, $MetadataBearer {
+    name: "InternalServerError";
+    $fault: "server";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace InternalServerError {
+    
+    const filterSensitiveLog: (obj: InternalServerError) => any;
+}
+
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace InvalidParameterException {
+    
+    const filterSensitiveLog: (obj: InvalidParameterException) => any;
+}
+
+export interface InvalidS3ObjectException extends __SmithyException, $MetadataBearer {
+    name: "InvalidS3ObjectException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace InvalidS3ObjectException {
+    
+    const filterSensitiveLog: (obj: InvalidS3ObjectException) => any;
+}
+
+export interface ProvisionedThroughputExceededException extends __SmithyException, $MetadataBearer {
+    name: "ProvisionedThroughputExceededException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace ProvisionedThroughputExceededException {
+    
+    const filterSensitiveLog: (obj: ProvisionedThroughputExceededException) => any;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "server";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace ThrottlingException {
+    
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+
+export interface UnsupportedDocumentException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedDocumentException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace UnsupportedDocumentException {
+    
+    const filterSensitiveLog: (obj: UnsupportedDocumentException) => any;
+}
+export interface AnalyzeExpenseRequest {
+    
+    Document: Document | undefined;
+}
+export declare namespace AnalyzeExpenseRequest {
+    
+    const filterSensitiveLog: (obj: AnalyzeExpenseRequest) => any;
+}
+
+export interface ExpenseDetection {
+    
+    Text?: string;
+    
+    Geometry?: Geometry;
+    
+    Confidence?: number;
+}
+export declare namespace ExpenseDetection {
+    
+    const filterSensitiveLog: (obj: ExpenseDetection) => any;
+}
+
+export interface ExpenseType {
+    
+    Text?: string;
+    
+    Confidence?: number;
+}
+export declare namespace ExpenseType {
+    
+    const filterSensitiveLog: (obj: ExpenseType) => any;
+}
+
+export interface ExpenseField {
+    
+    Type?: ExpenseType;
+    
+    LabelDetection?: ExpenseDetection;
+    
+    ValueDetection?: ExpenseDetection;
+    
+    PageNumber?: number;
+}
+export declare namespace ExpenseField {
+    
+    const filterSensitiveLog: (obj: ExpenseField) => any;
+}
+
+export interface LineItemFields {
+    
+    LineItemExpenseFields?: ExpenseField[];
+}
+export declare namespace LineItemFields {
+    
+    const filterSensitiveLog: (obj: LineItemFields) => any;
+}
+
+export interface LineItemGroup {
+    
+    LineItemGroupIndex?: number;
+    
+    LineItems?: LineItemFields[];
+}
+export declare namespace LineItemGroup {
+    
+    const filterSensitiveLog: (obj: LineItemGroup) => any;
+}
+
+export interface ExpenseDocument {
+    
+    ExpenseIndex?: number;
+    
+    SummaryFields?: ExpenseField[];
+    
+    LineItemGroups?: LineItemGroup[];
+}
+export declare namespace ExpenseDocument {
+    
+    const filterSensitiveLog: (obj: ExpenseDocument) => any;
+}
+export interface AnalyzeExpenseResponse {
+    
+    DocumentMetadata?: DocumentMetadata;
+    
+    ExpenseDocuments?: ExpenseDocument[];
+}
+export declare namespace AnalyzeExpenseResponse {
+    
+    const filterSensitiveLog: (obj: AnalyzeExpenseResponse) => any;
+}
+export interface DetectDocumentTextRequest {
+    
+    Document: Document | undefined;
+}
+export declare namespace DetectDocumentTextRequest {
+    
+    const filterSensitiveLog: (obj: DetectDocumentTextRequest) => any;
+}
+export interface DetectDocumentTextResponse {
+    
+    DocumentMetadata?: DocumentMetadata;
+    
+    Blocks?: Block[];
+    
+    DetectDocumentTextModelVersion?: string;
+}
+export declare namespace DetectDocumentTextResponse {
+    
+    const filterSensitiveLog: (obj: DetectDocumentTextResponse) => any;
+}
+
+export interface DocumentLocation {
+    
+    S3Object?: S3Object;
+}
+export declare namespace DocumentLocation {
+    
+    const filterSensitiveLog: (obj: DocumentLocation) => any;
+}
+export interface GetDocumentAnalysisRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetDocumentAnalysisRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentAnalysisRequest) => any;
+}
+export declare enum JobStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    PARTIAL_SUCCESS = "PARTIAL_SUCCESS",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface Warning {
+    
+    ErrorCode?: string;
+    
+    Pages?: number[];
+}
+export declare namespace Warning {
+    
+    const filterSensitiveLog: (obj: Warning) => any;
+}
+export interface GetDocumentAnalysisResponse {
+    
+    DocumentMetadata?: DocumentMetadata;
+    
+    JobStatus?: JobStatus | string;
+    
+    NextToken?: string;
+    
+    Blocks?: Block[];
+    
+    Warnings?: Warning[];
+    
+    StatusMessage?: string;
+    
+    AnalyzeDocumentModelVersion?: string;
+}
+export declare namespace GetDocumentAnalysisResponse {
+    
+    const filterSensitiveLog: (obj: GetDocumentAnalysisResponse) => any;
+}
+
+export interface InvalidJobIdException extends __SmithyException, $MetadataBearer {
+    name: "InvalidJobIdException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace InvalidJobIdException {
+    
+    const filterSensitiveLog: (obj: InvalidJobIdException) => any;
+}
+
+export interface InvalidKMSKeyException extends __SmithyException, $MetadataBearer {
+    name: "InvalidKMSKeyException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace InvalidKMSKeyException {
+    
+    const filterSensitiveLog: (obj: InvalidKMSKeyException) => any;
+}
+export interface GetDocumentTextDetectionRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetDocumentTextDetectionRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentTextDetectionRequest) => any;
+}
+export interface GetDocumentTextDetectionResponse {
+    
+    DocumentMetadata?: DocumentMetadata;
+    
+    JobStatus?: JobStatus | string;
+    
+    NextToken?: string;
+    
+    Blocks?: Block[];
+    
+    Warnings?: Warning[];
+    
+    StatusMessage?: string;
+    
+    DetectDocumentTextModelVersion?: string;
+}
+export declare namespace GetDocumentTextDetectionResponse {
+    
+    const filterSensitiveLog: (obj: GetDocumentTextDetectionResponse) => any;
+}
+
+export interface IdempotentParameterMismatchException extends __SmithyException, $MetadataBearer {
+    name: "IdempotentParameterMismatchException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace IdempotentParameterMismatchException {
+    
+    const filterSensitiveLog: (obj: IdempotentParameterMismatchException) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface NotificationChannel {
+    
+    SNSTopicArn: string | undefined;
+    
+    RoleArn: string | undefined;
+}
+export declare namespace NotificationChannel {
+    
+    const filterSensitiveLog: (obj: NotificationChannel) => any;
+}
+
+export interface OutputConfig {
+    
+    S3Bucket: string | undefined;
+    
+    S3Prefix?: string;
+}
+export declare namespace OutputConfig {
+    
+    const filterSensitiveLog: (obj: OutputConfig) => any;
+}
+export interface StartDocumentAnalysisRequest {
+    
+    DocumentLocation: DocumentLocation | undefined;
+    
+    FeatureTypes: (FeatureType | string)[] | undefined;
+    
+    ClientRequestToken?: string;
+    
+    JobTag?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    OutputConfig?: OutputConfig;
+    
+    KMSKeyId?: string;
+}
+export declare namespace StartDocumentAnalysisRequest {
+    
+    const filterSensitiveLog: (obj: StartDocumentAnalysisRequest) => any;
+}
+export interface StartDocumentAnalysisResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartDocumentAnalysisResponse {
+    
+    const filterSensitiveLog: (obj: StartDocumentAnalysisResponse) => any;
+}
+export interface StartDocumentTextDetectionRequest {
+    
+    DocumentLocation: DocumentLocation | undefined;
+    
+    ClientRequestToken?: string;
+    
+    JobTag?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    OutputConfig?: OutputConfig;
+    
+    KMSKeyId?: string;
+}
+export declare namespace StartDocumentTextDetectionRequest {
+    
+    const filterSensitiveLog: (obj: StartDocumentTextDetectionRequest) => any;
+}
+export interface StartDocumentTextDetectionResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartDocumentTextDetectionResponse {
+    
+    const filterSensitiveLog: (obj: StartDocumentTextDetectionResponse) => any;
+}

package/{dist/types → dist-types}/ts3.4/protocols/Aws_json1_1.d.ts

@@ -1,3 +1,5 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
 import { AnalyzeDocumentCommandInput, AnalyzeDocumentCommandOutput } from "../commands/AnalyzeDocumentCommand";
 import { AnalyzeExpenseCommandInput, AnalyzeExpenseCommandOutput } from "../commands/AnalyzeExpenseCommand";
 import { DetectDocumentTextCommandInput, DetectDocumentTextCommandOutput } from "../commands/DetectDocumentTextCommand";
@@ -5,8 +7,6 @@ import { GetDocumentAnalysisCommandInput, GetDocumentAnalysisCommandOutput } fro
 import { GetDocumentTextDetectionCommandInput, GetDocumentTextDetectionCommandOutput } from "../commands/GetDocumentTextDetectionCommand";
 import { StartDocumentAnalysisCommandInput, StartDocumentAnalysisCommandOutput } from "../commands/StartDocumentAnalysisCommand";
 import { StartDocumentTextDetectionCommandInput, StartDocumentTextDetectionCommandOutput } from "../commands/StartDocumentTextDetectionCommand";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
 export declare const serializeAws_json1_1AnalyzeDocumentCommand: (input: AnalyzeDocumentCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_json1_1AnalyzeExpenseCommand: (input: AnalyzeExpenseCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_json1_1DetectDocumentTextCommand: (input: DetectDocumentTextCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;

package/{dist/types → dist-types}/ts3.4/runtimeConfig.browser.d.ts

@@ -1,8 +1,6 @@
 import { FetchHttpHandler } from "@aws-sdk/fetch-http-handler";
 import { TextractClientConfig } from "./TextractClient";
-/**
- * @internal
- */
+
 export declare const getRuntimeConfig: (config: TextractClientConfig) => {
     runtime: string;
     base64Decoder: import("@aws-sdk/types").Decoder;

package/{dist/types → dist-types}/ts3.4/runtimeConfig.d.ts

@@ -1,14 +1,12 @@
 import { NodeHttpHandler } from "@aws-sdk/node-http-handler";
 import { TextractClientConfig } from "./TextractClient";
-/**
- * @internal
- */
+
 export declare const getRuntimeConfig: (config: TextractClientConfig) => {
     runtime: string;
     base64Decoder: import("@aws-sdk/types").Decoder;
     base64Encoder: import("@aws-sdk/types").Encoder;
     bodyLengthChecker: (body: any) => number | undefined;
-    credentialDefaultProvider: import("@aws-sdk/client-sts/dist/types/defaultStsRoleAssumers").DefaultCredentialProvider;
+    credentialDefaultProvider: import("@aws-sdk/client-sts/dist-types/defaultStsRoleAssumers").DefaultCredentialProvider;
     defaultUserAgentProvider: import("@aws-sdk/types").Provider<import("@aws-sdk/types").UserAgent>;
     maxAttempts: number | import("@aws-sdk/types").Provider<number>;
     region: string | import("@aws-sdk/types").Provider<string>;

package/{dist/types → dist-types}/ts3.4/runtimeConfig.native.d.ts

@@ -1,7 +1,5 @@
 import { TextractClientConfig } from "./TextractClient";
-/**
- * @internal
- */
+
 export declare const getRuntimeConfig: (config: TextractClientConfig) => {
     runtime: string;
     sha256: import("@aws-sdk/types").HashConstructor;

package/{dist/types → dist-types}/ts3.4/runtimeConfig.shared.d.ts

@@ -1,8 +1,6 @@
 import { Logger as __Logger } from "@aws-sdk/types";
 import { TextractClientConfig } from "./TextractClient";
-/**
- * @internal
- */
+
 export declare const getRuntimeConfig: (config: TextractClientConfig) => {
     apiVersion: string;
     disableHostPrefix: boolean;