@aws-sdk/client-textract 3.50.0 → 3.53.0

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

@@ -0,0 +1,753 @@
+import { ExceptionOptionType as __ExceptionOptionType, LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
+import { TextractServiceException as __BaseException } from "./TextractServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+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",
+    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"
+}
+
+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",
+    MERGED_CELL = "MERGED_CELL",
+    TITLE = "TITLE",
+    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 declare class BadDocumentException extends __BaseException {
+    readonly name: "BadDocumentException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<BadDocumentException, __BaseException>);
+}
+
+export declare class DocumentTooLargeException extends __BaseException {
+    readonly name: "DocumentTooLargeException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<DocumentTooLargeException, __BaseException>);
+}
+
+export declare class HumanLoopQuotaExceededException extends __BaseException {
+    readonly name: "HumanLoopQuotaExceededException";
+    readonly $fault: "client";
+    
+    ResourceType?: string;
+    
+    QuotaCode?: string;
+    
+    ServiceCode?: string;
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<HumanLoopQuotaExceededException, __BaseException>);
+}
+
+export declare class InternalServerError extends __BaseException {
+    readonly name: "InternalServerError";
+    readonly $fault: "server";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerError, __BaseException>);
+}
+
+export declare class InvalidParameterException extends __BaseException {
+    readonly name: "InvalidParameterException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterException, __BaseException>);
+}
+
+export declare class InvalidS3ObjectException extends __BaseException {
+    readonly name: "InvalidS3ObjectException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidS3ObjectException, __BaseException>);
+}
+
+export declare class ProvisionedThroughputExceededException extends __BaseException {
+    readonly name: "ProvisionedThroughputExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<ProvisionedThroughputExceededException, __BaseException>);
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "server";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+
+export declare class UnsupportedDocumentException extends __BaseException {
+    readonly name: "UnsupportedDocumentException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedDocumentException, __BaseException>);
+}
+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 AnalyzeIDRequest {
+    
+    DocumentPages: Document[] | undefined;
+}
+export declare namespace AnalyzeIDRequest {
+    
+    const filterSensitiveLog: (obj: AnalyzeIDRequest) => any;
+}
+export declare enum ValueType {
+    DATE = "DATE"
+}
+
+export interface NormalizedValue {
+    
+    Value?: string;
+    
+    ValueType?: ValueType | string;
+}
+export declare namespace NormalizedValue {
+    
+    const filterSensitiveLog: (obj: NormalizedValue) => any;
+}
+
+export interface AnalyzeIDDetections {
+    
+    Text: string | undefined;
+    
+    NormalizedValue?: NormalizedValue;
+    
+    Confidence?: number;
+}
+export declare namespace AnalyzeIDDetections {
+    
+    const filterSensitiveLog: (obj: AnalyzeIDDetections) => any;
+}
+
+export interface IdentityDocumentField {
+    
+    Type?: AnalyzeIDDetections;
+    
+    ValueDetection?: AnalyzeIDDetections;
+}
+export declare namespace IdentityDocumentField {
+    
+    const filterSensitiveLog: (obj: IdentityDocumentField) => any;
+}
+
+export interface IdentityDocument {
+    
+    DocumentIndex?: number;
+    
+    IdentityDocumentFields?: IdentityDocumentField[];
+}
+export declare namespace IdentityDocument {
+    
+    const filterSensitiveLog: (obj: IdentityDocument) => any;
+}
+export interface AnalyzeIDResponse {
+    
+    IdentityDocuments?: IdentityDocument[];
+    
+    DocumentMetadata?: DocumentMetadata;
+    
+    AnalyzeIDModelVersion?: string;
+}
+export declare namespace AnalyzeIDResponse {
+    
+    const filterSensitiveLog: (obj: AnalyzeIDResponse) => 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 declare class InvalidJobIdException extends __BaseException {
+    readonly name: "InvalidJobIdException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidJobIdException, __BaseException>);
+}
+
+export declare class InvalidKMSKeyException extends __BaseException {
+    readonly name: "InvalidKMSKeyException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidKMSKeyException, __BaseException>);
+}
+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 GetExpenseAnalysisRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetExpenseAnalysisRequest {
+    
+    const filterSensitiveLog: (obj: GetExpenseAnalysisRequest) => any;
+}
+export interface GetExpenseAnalysisResponse {
+    
+    DocumentMetadata?: DocumentMetadata;
+    
+    JobStatus?: JobStatus | string;
+    
+    NextToken?: string;
+    
+    ExpenseDocuments?: ExpenseDocument[];
+    
+    Warnings?: Warning[];
+    
+    StatusMessage?: string;
+    
+    AnalyzeExpenseModelVersion?: string;
+}
+export declare namespace GetExpenseAnalysisResponse {
+    
+    const filterSensitiveLog: (obj: GetExpenseAnalysisResponse) => any;
+}
+
+export declare class IdempotentParameterMismatchException extends __BaseException {
+    readonly name: "IdempotentParameterMismatchException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<IdempotentParameterMismatchException, __BaseException>);
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+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;
+}
+export interface StartExpenseAnalysisRequest {
+    
+    DocumentLocation: DocumentLocation | undefined;
+    
+    ClientRequestToken?: string;
+    
+    JobTag?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    OutputConfig?: OutputConfig;
+    
+    KMSKeyId?: string;
+}
+export declare namespace StartExpenseAnalysisRequest {
+    
+    const filterSensitiveLog: (obj: StartExpenseAnalysisRequest) => any;
+}
+export interface StartExpenseAnalysisResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartExpenseAnalysisResponse {
+    
+    const filterSensitiveLog: (obj: StartExpenseAnalysisResponse) => any;
+}