Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException

type AccessDeniedException struct {
	Message *string

	Code *string
}

    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.

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

    func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type BadDocumentException

    type BadDocumentException struct {
    	Message *string
    
    	Code *string
    }

      Amazon Textract isn't able to read the document. For more information on the document limits in Amazon Textract, see limits.

      func (*BadDocumentException) Error

      func (e *BadDocumentException) Error() string

      func (*BadDocumentException) ErrorCode

      func (e *BadDocumentException) ErrorCode() string

      func (*BadDocumentException) ErrorFault

      func (e *BadDocumentException) ErrorFault() smithy.ErrorFault

      func (*BadDocumentException) ErrorMessage

      func (e *BadDocumentException) ErrorMessage() string

      type Block

      type Block struct {
      
      	// The type of text item that's recognized. In operations for text detection, the
      	// following types are returned:
      	//
      	// * PAGE - Contains a list of the LINE Block
      	// objects that are detected on a document page.
      	//
      	// * WORD - A word detected on a
      	// document page. A word is one or more ISO basic Latin script characters that
      	// aren't separated by spaces.
      	//
      	// * LINE - A string of tab-delimited, contiguous
      	// words that are detected on a document page.
      	//
      	// In text analysis operations, the
      	// following types are returned:
      	//
      	// * PAGE - Contains a list of child Block objects
      	// that are detected on a document page.
      	//
      	// * KEY_VALUE_SET - Stores the KEY and
      	// VALUE Block objects for linked text that's detected on a document page. Use the
      	// EntityType field to determine if a KEY_VALUE_SET object is a KEY Block object or
      	// a VALUE Block object.
      	//
      	// * WORD - A word that's detected on a document page. A
      	// word is one or more ISO basic Latin script characters that aren't separated by
      	// spaces.
      	//
      	// * LINE - A string of tab-delimited, contiguous words that are detected
      	// on a document page.
      	//
      	// * TABLE - A table that's detected on a document page. A
      	// table is grid-based information with two or more rows or columns, with a cell
      	// span of one row and one column each.
      	//
      	// * CELL - A cell within a detected table.
      	// The cell is the parent of the block that contains the text in the cell.
      	//
      	// *
      	// SELECTION_ELEMENT - A selection element such as an option button (radio button)
      	// or a check box that's detected on a document page. Use the value of
      	// SelectionStatus to determine the status of the selection element.
      	BlockType BlockType
      
      	// The column in which a table cell appears. The first column position is 1.
      	// ColumnIndex isn't returned by DetectDocumentText and GetDocumentTextDetection.
      	ColumnIndex *int32
      
      	// The number of columns that a table cell spans. Currently this value is always 1,
      	// even if the number of columns spanned is greater than 1. ColumnSpan isn't
      	// returned by DetectDocumentText and GetDocumentTextDetection.
      	ColumnSpan *int32
      
      	// The confidence score that Amazon Textract has in the accuracy of the recognized
      	// text and the accuracy of the geometry points around the recognized text.
      	Confidence *float32
      
      	// The type of entity. The following can be returned:
      	//
      	// * KEY - An identifier for a
      	// field on the document.
      	//
      	// * VALUE - The field text.
      	//
      	// EntityTypes isn't returned by
      	// DetectDocumentText and GetDocumentTextDetection.
      	EntityTypes []EntityType
      
      	// The location of the recognized text on the image. It includes an axis-aligned,
      	// coarse bounding box that surrounds the text, and a finer-grain polygon for more
      	// accurate spatial information.
      	Geometry *Geometry
      
      	// The identifier for the recognized text. The identifier is only unique for a
      	// single operation.
      	Id *string
      
      	// The page on which a block was detected. Page is returned by asynchronous
      	// operations. Page values greater than 1 are only returned for multipage documents
      	// that are in PDF format. A scanned image (JPEG/PNG), even if it contains multiple
      	// document pages, is considered to be a single-page document. The value of Page is
      	// always 1. Synchronous operations don't return Page because every input document
      	// is considered to be a single-page document.
      	Page *int32
      
      	// A list of child blocks of the current block. For example, a LINE object has
      	// child blocks for each WORD block that's part of the line of text. There aren't
      	// Relationship objects in the list for relationships that don't exist, such as
      	// when the current block has no child blocks. The list size can be the
      	// following:
      	//
      	// * 0 - The block has no child blocks.
      	//
      	// * 1 - The block has child
      	// blocks.
      	Relationships []Relationship
      
      	// The row in which a table cell is located. The first row position is 1. RowIndex
      	// isn't returned by DetectDocumentText and GetDocumentTextDetection.
      	RowIndex *int32
      
      	// The number of rows that a table cell spans. Currently this value is always 1,
      	// even if the number of rows spanned is greater than 1. RowSpan isn't returned by
      	// DetectDocumentText and GetDocumentTextDetection.
      	RowSpan *int32
      
      	// The selection status of a selection element, such as an option button or check
      	// box.
      	SelectionStatus SelectionStatus
      
      	// The word or line of text that's recognized by Amazon Textract.
      	Text *string
      
      	// The kind of text that Amazon Textract has detected. Can check for handwritten
      	// text and printed text.
      	TextType TextType
      }

        A Block represents items that are recognized in a document within a group of pixels close to each other. The information returned in a Block object depends on the type of operation. In text detection for documents (for example DetectDocumentText), you get information about the detected words and lines of text. In text analysis (for example AnalyzeDocument), you can also get information about the fields, tables, and selection elements that are detected in the document. An array of Block objects is returned by both synchronous and asynchronous operations. In synchronous operations, such as DetectDocumentText, the array of Block objects is the entire set of results. In asynchronous operations, such as GetDocumentAnalysis, the array is returned over one or more responses. For more information, see How Amazon Textract Works (https://docs.aws.amazon.com/textract/latest/dg/how-it-works.html).

        type BlockType

        type BlockType string
        const (
        	BlockTypeKeyValueSet      BlockType = "KEY_VALUE_SET"
        	BlockTypePage             BlockType = "PAGE"
        	BlockTypeLine             BlockType = "LINE"
        	BlockTypeWord             BlockType = "WORD"
        	BlockTypeTable            BlockType = "TABLE"
        	BlockTypeCell             BlockType = "CELL"
        	BlockTypeSelectionElement BlockType = "SELECTION_ELEMENT"
        )

          Enum values for BlockType

          func (BlockType) Values

          func (BlockType) Values() []BlockType

            Values returns all known values for BlockType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

            type BoundingBox

            type BoundingBox struct {
            
            	// The height of the bounding box as a ratio of the overall document page height.
            	Height float32
            
            	// The left coordinate of the bounding box as a ratio of overall document page
            	// width.
            	Left float32
            
            	// The top coordinate of the bounding box as a ratio of overall document page
            	// height.
            	Top float32
            
            	// The width of the bounding box as a ratio of the overall document page width.
            	Width float32
            }

              The bounding box around the detected page, text, key-value pair, table, table cell, or selection element on a document page. The left (x-coordinate) and top (y-coordinate) are coordinates that represent the top and left sides of the bounding box. Note that the upper-left corner of the image is the origin (0,0). The top and left values returned are ratios of the overall document page size. For example, if the input image is 700 x 200 pixels, and the top-left coordinate of the bounding box is 350 x 50 pixels, the API returns a left value of 0.5 (350/700) and a top value of 0.25 (50/200). The width and height values represent the dimensions of the bounding box as a ratio of the overall document page dimension. For example, if the document page size is 700 x 200 pixels, and the bounding box width is 70 pixels, the width returned is 0.1.

              type ContentClassifier

              type ContentClassifier string
              const (
              	ContentClassifierFreeOfPersonallyIdentifiableInformation ContentClassifier = "FreeOfPersonallyIdentifiableInformation"
              	ContentClassifierFreeOfAdultContent                      ContentClassifier = "FreeOfAdultContent"
              )

                Enum values for ContentClassifier

                func (ContentClassifier) Values

                  Values returns all known values for ContentClassifier. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                  type Document

                  type Document struct {
                  
                  	// A blob of base64-encoded document bytes. The maximum size of a document that's
                  	// provided in a blob of bytes is 5 MB. The document bytes must be in PNG or JPEG
                  	// format. If you're using an AWS SDK to call Amazon Textract, you might not need
                  	// to base64-encode image bytes passed using the Bytes field.
                  	Bytes []byte
                  
                  	// Identifies an S3 object as the document source. The maximum size of a document
                  	// that's stored in an S3 bucket is 5 MB.
                  	S3Object *S3Object
                  }

                    The input document, either as bytes or as an S3 object. You pass image bytes to an Amazon Textract API operation by using the Bytes property. For example, you would use the Bytes property to pass a document loaded from a local file system. Image bytes passed by using the Bytes property must be base64 encoded. Your code might not need to encode document file bytes if you're using an AWS SDK to call Amazon Textract API operations. You pass images stored in an S3 bucket to an Amazon Textract API operation by using the S3Object property. Documents stored in an S3 bucket don't need to be base64 encoded. The AWS Region for the S3 bucket that contains the S3 object must match the AWS Region that you use for Amazon Textract operations. If you use the AWS CLI to call Amazon Textract operations, passing image bytes using the Bytes property isn't supported. You must first upload the document to an Amazon S3 bucket, and then call the operation using the S3Object property. For Amazon Textract to process an S3 object, the user must have permission to access the S3 object.

                    type DocumentLocation

                    type DocumentLocation struct {
                    
                    	// The Amazon S3 bucket that contains the input document.
                    	S3Object *S3Object
                    }

                      The Amazon S3 bucket that contains the document to be processed. It's used by asynchronous operations such as StartDocumentTextDetection. The input document can be an image file in JPEG or PNG format. It can also be a file in PDF format.

                      type DocumentMetadata

                      type DocumentMetadata struct {
                      
                      	// The number of pages that are detected in the document.
                      	Pages *int32
                      }

                        Information about the input document.

                        type DocumentTooLargeException

                        type DocumentTooLargeException struct {
                        	Message *string
                        
                        	Code *string
                        }

                          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.

                          func (*DocumentTooLargeException) Error

                          func (e *DocumentTooLargeException) Error() string

                          func (*DocumentTooLargeException) ErrorCode

                          func (e *DocumentTooLargeException) ErrorCode() string

                          func (*DocumentTooLargeException) ErrorFault

                          func (*DocumentTooLargeException) ErrorMessage

                          func (e *DocumentTooLargeException) ErrorMessage() string

                          type EntityType

                          type EntityType string
                          const (
                          	EntityTypeKey   EntityType = "KEY"
                          	EntityTypeValue EntityType = "VALUE"
                          )

                            Enum values for EntityType

                            func (EntityType) Values

                            func (EntityType) Values() []EntityType

                              Values returns all known values for EntityType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                              type FeatureType

                              type FeatureType string
                              const (
                              	FeatureTypeTables FeatureType = "TABLES"
                              	FeatureTypeForms  FeatureType = "FORMS"
                              )

                                Enum values for FeatureType

                                func (FeatureType) Values

                                func (FeatureType) Values() []FeatureType

                                  Values returns all known values for FeatureType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                  type Geometry

                                  type Geometry struct {
                                  
                                  	// An axis-aligned coarse representation of the location of the recognized item on
                                  	// the document page.
                                  	BoundingBox *BoundingBox
                                  
                                  	// Within the bounding box, a fine-grained polygon around the recognized item.
                                  	Polygon []Point
                                  }

                                    Information about where the following items are located on a document page: detected page, text, key-value pairs, tables, table cells, and selection elements.

                                    type HumanLoopActivationOutput

                                    type HumanLoopActivationOutput struct {
                                    
                                    	// Shows the result of condition evaluations, including those conditions which
                                    	// activated a human review.
                                    	//
                                    	// This value conforms to the media type: application/json
                                    	HumanLoopActivationConditionsEvaluationResults *string
                                    
                                    	// Shows if and why human review was needed.
                                    	HumanLoopActivationReasons []string
                                    
                                    	// The Amazon Resource Name (ARN) of the HumanLoop created.
                                    	HumanLoopArn *string
                                    }

                                      Shows the results of the human in the loop evaluation. If there is no HumanLoopArn, the input did not trigger human review.

                                      type HumanLoopConfig

                                      type HumanLoopConfig struct {
                                      
                                      	// The Amazon Resource Name (ARN) of the flow definition.
                                      	//
                                      	// This member is required.
                                      	FlowDefinitionArn *string
                                      
                                      	// The name of the human workflow used for this image. This should be kept unique
                                      	// within a region.
                                      	//
                                      	// This member is required.
                                      	HumanLoopName *string
                                      
                                      	// Sets attributes of the input data.
                                      	DataAttributes *HumanLoopDataAttributes
                                      }

                                        Sets up the human review workflow the document will be sent to if one of the conditions is met. You can also set certain attributes of the image before review.

                                        type HumanLoopDataAttributes

                                        type HumanLoopDataAttributes struct {
                                        
                                        	// Sets whether the input image is free of personally identifiable information or
                                        	// adult content.
                                        	ContentClassifiers []ContentClassifier
                                        }

                                          Allows you to set attributes of the image. Currently, you can declare an image as free of personally identifiable information and adult content.

                                          type HumanLoopQuotaExceededException

                                          type HumanLoopQuotaExceededException struct {
                                          	Message *string
                                          
                                          	ResourceType *string
                                          	QuotaCode    *string
                                          	ServiceCode  *string
                                          	Code         *string
                                          }

                                            Indicates you have exceeded the maximum number of active human in the loop workflows available

                                            func (*HumanLoopQuotaExceededException) Error

                                            func (*HumanLoopQuotaExceededException) ErrorCode

                                            func (e *HumanLoopQuotaExceededException) ErrorCode() string

                                            func (*HumanLoopQuotaExceededException) ErrorFault

                                            func (*HumanLoopQuotaExceededException) ErrorMessage

                                            func (e *HumanLoopQuotaExceededException) ErrorMessage() string

                                            type IdempotentParameterMismatchException

                                            type IdempotentParameterMismatchException struct {
                                            	Message *string
                                            
                                            	Code *string
                                            }

                                              A ClientRequestToken input parameter was reused with an operation, but at least one of the other input parameters is different from the previous call to the operation.

                                              func (*IdempotentParameterMismatchException) Error

                                              func (*IdempotentParameterMismatchException) ErrorCode

                                              func (*IdempotentParameterMismatchException) ErrorFault

                                              func (*IdempotentParameterMismatchException) ErrorMessage

                                              func (e *IdempotentParameterMismatchException) ErrorMessage() string

                                              type InternalServerError

                                              type InternalServerError struct {
                                              	Message *string
                                              
                                              	Code *string
                                              }

                                                Amazon Textract experienced a service issue. Try your call again.

                                                func (*InternalServerError) Error

                                                func (e *InternalServerError) Error() string

                                                func (*InternalServerError) ErrorCode

                                                func (e *InternalServerError) ErrorCode() string

                                                func (*InternalServerError) ErrorFault

                                                func (e *InternalServerError) ErrorFault() smithy.ErrorFault

                                                func (*InternalServerError) ErrorMessage

                                                func (e *InternalServerError) ErrorMessage() string

                                                type InvalidJobIdException

                                                type InvalidJobIdException struct {
                                                	Message *string
                                                
                                                	Code *string
                                                }

                                                  An invalid job identifier was passed to GetDocumentAnalysis or to GetDocumentAnalysis.

                                                  func (*InvalidJobIdException) Error

                                                  func (e *InvalidJobIdException) Error() string

                                                  func (*InvalidJobIdException) ErrorCode

                                                  func (e *InvalidJobIdException) ErrorCode() string

                                                  func (*InvalidJobIdException) ErrorFault

                                                  func (e *InvalidJobIdException) ErrorFault() smithy.ErrorFault

                                                  func (*InvalidJobIdException) ErrorMessage

                                                  func (e *InvalidJobIdException) ErrorMessage() string

                                                  type InvalidKMSKeyException

                                                  type InvalidKMSKeyException struct {
                                                  	Message *string
                                                  
                                                  	Code *string
                                                  }

                                                    Indicates you do not have decrypt permissions with the KMS key entered, or the KMS key was entered incorrectly.

                                                    func (*InvalidKMSKeyException) Error

                                                    func (e *InvalidKMSKeyException) Error() string

                                                    func (*InvalidKMSKeyException) ErrorCode

                                                    func (e *InvalidKMSKeyException) ErrorCode() string

                                                    func (*InvalidKMSKeyException) ErrorFault

                                                    func (e *InvalidKMSKeyException) ErrorFault() smithy.ErrorFault

                                                    func (*InvalidKMSKeyException) ErrorMessage

                                                    func (e *InvalidKMSKeyException) ErrorMessage() string

                                                    type InvalidParameterException

                                                    type InvalidParameterException struct {
                                                    	Message *string
                                                    
                                                    	Code *string
                                                    }

                                                      An input parameter violated a constraint. For example, in synchronous operations, an InvalidParameterException exception occurs when neither of the S3Object or Bytes values are supplied in the Document request parameter. Validate your parameter before calling the API operation again.

                                                      func (*InvalidParameterException) Error

                                                      func (e *InvalidParameterException) Error() string

                                                      func (*InvalidParameterException) ErrorCode

                                                      func (e *InvalidParameterException) ErrorCode() string

                                                      func (*InvalidParameterException) ErrorFault

                                                      func (*InvalidParameterException) ErrorMessage

                                                      func (e *InvalidParameterException) ErrorMessage() string

                                                      type InvalidS3ObjectException

                                                      type InvalidS3ObjectException struct {
                                                      	Message *string
                                                      
                                                      	Code *string
                                                      }

                                                        Amazon Textract is unable to access the S3 object that's specified in the request. for more information, Configure Access to Amazon S3 (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-access-control.html) For troubleshooting information, see Troubleshooting Amazon S3 (https://docs.aws.amazon.com/AmazonS3/latest/dev/troubleshooting.html)

                                                        func (*InvalidS3ObjectException) Error

                                                        func (e *InvalidS3ObjectException) Error() string

                                                        func (*InvalidS3ObjectException) ErrorCode

                                                        func (e *InvalidS3ObjectException) ErrorCode() string

                                                        func (*InvalidS3ObjectException) ErrorFault

                                                        func (e *InvalidS3ObjectException) ErrorFault() smithy.ErrorFault

                                                        func (*InvalidS3ObjectException) ErrorMessage

                                                        func (e *InvalidS3ObjectException) ErrorMessage() string

                                                        type JobStatus

                                                        type JobStatus string
                                                        const (
                                                        	JobStatusInProgress     JobStatus = "IN_PROGRESS"
                                                        	JobStatusSucceeded      JobStatus = "SUCCEEDED"
                                                        	JobStatusFailed         JobStatus = "FAILED"
                                                        	JobStatusPartialSuccess JobStatus = "PARTIAL_SUCCESS"
                                                        )

                                                          Enum values for JobStatus

                                                          func (JobStatus) Values

                                                          func (JobStatus) Values() []JobStatus

                                                            Values returns all known values for JobStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                            type LimitExceededException

                                                            type LimitExceededException struct {
                                                            	Message *string
                                                            
                                                            	Code *string
                                                            }

                                                              An Amazon Textract service limit was exceeded. For example, if you start too many asynchronous jobs concurrently, calls to start operations (StartDocumentTextDetection, for example) raise a LimitExceededException exception (HTTP status code: 400) until the number of concurrently running jobs is below the Amazon Textract service limit.

                                                              func (*LimitExceededException) Error

                                                              func (e *LimitExceededException) Error() string

                                                              func (*LimitExceededException) ErrorCode

                                                              func (e *LimitExceededException) ErrorCode() string

                                                              func (*LimitExceededException) ErrorFault

                                                              func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                              func (*LimitExceededException) ErrorMessage

                                                              func (e *LimitExceededException) ErrorMessage() string

                                                              type NotificationChannel

                                                              type NotificationChannel struct {
                                                              
                                                              	// The Amazon Resource Name (ARN) of an IAM role that gives Amazon Textract
                                                              	// publishing permissions to the Amazon SNS topic.
                                                              	//
                                                              	// This member is required.
                                                              	RoleArn *string
                                                              
                                                              	// The Amazon SNS topic that Amazon Textract posts the completion status to.
                                                              	//
                                                              	// This member is required.
                                                              	SNSTopicArn *string
                                                              }

                                                                The Amazon Simple Notification Service (Amazon SNS) topic to which Amazon Textract publishes the completion status of an asynchronous document operation, such as StartDocumentTextDetection.

                                                                type OutputConfig

                                                                type OutputConfig struct {
                                                                
                                                                	// The name of the bucket your output will go to.
                                                                	//
                                                                	// This member is required.
                                                                	S3Bucket *string
                                                                
                                                                	// The prefix of the object key that the output will be saved to. When not enabled,
                                                                	// the prefix will be “textract_output".
                                                                	S3Prefix *string
                                                                }

                                                                  Sets whether or not your output will go to a user created bucket. Used to set the name of the bucket, and the prefix on the output file.

                                                                  type Point

                                                                  type Point struct {
                                                                  
                                                                  	// The value of the X coordinate for a point on a Polygon.
                                                                  	X float32
                                                                  
                                                                  	// The value of the Y coordinate for a point on a Polygon.
                                                                  	Y float32
                                                                  }

                                                                    The X and Y coordinates of a point on a document page. The X and Y values that are returned are ratios of the overall document page size. For example, if the input document is 700 x 200 and the operation returns X=0.5 and Y=0.25, then the point is at the (350,50) pixel coordinate on the document page. An array of Point objects, Polygon, is returned by DetectDocumentText. Polygon represents a fine-grained polygon around detected text. For more information, see Geometry in the Amazon Textract Developer Guide.

                                                                    type ProvisionedThroughputExceededException

                                                                    type ProvisionedThroughputExceededException struct {
                                                                    	Message *string
                                                                    
                                                                    	Code *string
                                                                    }

                                                                      The number of requests exceeded your throughput limit. If you want to increase this limit, contact Amazon Textract.

                                                                      func (*ProvisionedThroughputExceededException) Error

                                                                      func (*ProvisionedThroughputExceededException) ErrorCode

                                                                      func (*ProvisionedThroughputExceededException) ErrorFault

                                                                      func (*ProvisionedThroughputExceededException) ErrorMessage

                                                                      type Relationship

                                                                      type Relationship struct {
                                                                      
                                                                      	// An array of IDs for related blocks. You can get the type of the relationship
                                                                      	// from the Type element.
                                                                      	Ids []string
                                                                      
                                                                      	// The type of relationship that the blocks in the IDs array have with the current
                                                                      	// block. The relationship can be VALUE or CHILD. A relationship of type VALUE is a
                                                                      	// list that contains the ID of the VALUE block that's associated with the KEY of a
                                                                      	// key-value pair. A relationship of type CHILD is a list of IDs that identify WORD
                                                                      	// blocks in the case of lines Cell blocks in the case of Tables, and WORD blocks
                                                                      	// in the case of Selection Elements.
                                                                      	Type RelationshipType
                                                                      }

                                                                        Information about how blocks are related to each other. A Block object contains 0 or more Relation objects in a list, Relationships. For more information, see Block. The Type element provides the type of the relationship for all blocks in the IDs array.

                                                                        type RelationshipType

                                                                        type RelationshipType string
                                                                        const (
                                                                        	RelationshipTypeValue           RelationshipType = "VALUE"
                                                                        	RelationshipTypeChild           RelationshipType = "CHILD"
                                                                        	RelationshipTypeComplexFeatures RelationshipType = "COMPLEX_FEATURES"
                                                                        )

                                                                          Enum values for RelationshipType

                                                                          func (RelationshipType) Values

                                                                            Values returns all known values for RelationshipType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                            type S3Object

                                                                            type S3Object struct {
                                                                            
                                                                            	// The name of the S3 bucket.
                                                                            	Bucket *string
                                                                            
                                                                            	// The file name of the input document. Synchronous operations can use image files
                                                                            	// that are in JPEG or PNG format. Asynchronous operations also support PDF format
                                                                            	// files.
                                                                            	Name *string
                                                                            
                                                                            	// If the bucket has versioning enabled, you can specify the object version.
                                                                            	Version *string
                                                                            }

                                                                              The S3 bucket name and file name that identifies the document. The AWS Region for the S3 bucket that contains the document must match the Region that you use for Amazon Textract operations. For Amazon Textract to process a file in an S3 bucket, the user must have permission to access the S3 bucket and file.

                                                                              type SelectionStatus

                                                                              type SelectionStatus string
                                                                              const (
                                                                              	SelectionStatusSelected    SelectionStatus = "SELECTED"
                                                                              	SelectionStatusNotSelected SelectionStatus = "NOT_SELECTED"
                                                                              )

                                                                                Enum values for SelectionStatus

                                                                                func (SelectionStatus) Values

                                                                                func (SelectionStatus) Values() []SelectionStatus

                                                                                  Values returns all known values for SelectionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                  type TextType

                                                                                  type TextType string
                                                                                  const (
                                                                                  	TextTypeHandwriting TextType = "HANDWRITING"
                                                                                  	TextTypePrinted     TextType = "PRINTED"
                                                                                  )

                                                                                    Enum values for TextType

                                                                                    func (TextType) Values

                                                                                    func (TextType) Values() []TextType

                                                                                      Values returns all known values for TextType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                      type ThrottlingException

                                                                                      type ThrottlingException struct {
                                                                                      	Message *string
                                                                                      
                                                                                      	Code *string
                                                                                      }

                                                                                        Amazon Textract is temporarily unable to process the request. Try your call again.

                                                                                        func (*ThrottlingException) Error

                                                                                        func (e *ThrottlingException) Error() string

                                                                                        func (*ThrottlingException) ErrorCode

                                                                                        func (e *ThrottlingException) ErrorCode() string

                                                                                        func (*ThrottlingException) ErrorFault

                                                                                        func (e *ThrottlingException) ErrorFault() smithy.ErrorFault

                                                                                        func (*ThrottlingException) ErrorMessage

                                                                                        func (e *ThrottlingException) ErrorMessage() string

                                                                                        type UnsupportedDocumentException

                                                                                        type UnsupportedDocumentException struct {
                                                                                        	Message *string
                                                                                        
                                                                                        	Code *string
                                                                                        }

                                                                                          The format of the input document isn't supported. Documents for synchronous operations can be in PNG or JPEG format. Documents for asynchronous operations can also be in PDF format.

                                                                                          func (*UnsupportedDocumentException) Error

                                                                                          func (*UnsupportedDocumentException) ErrorCode

                                                                                          func (e *UnsupportedDocumentException) ErrorCode() string

                                                                                          func (*UnsupportedDocumentException) ErrorFault

                                                                                          func (*UnsupportedDocumentException) ErrorMessage

                                                                                          func (e *UnsupportedDocumentException) ErrorMessage() string

                                                                                          type Warning

                                                                                          type Warning struct {
                                                                                          
                                                                                          	// The error code for the warning.
                                                                                          	ErrorCode *string
                                                                                          
                                                                                          	// A list of the pages that the warning applies to.
                                                                                          	Pages []int32
                                                                                          }

                                                                                            A warning about an issue that occurred during asynchronous text analysis (StartDocumentAnalysis) or asynchronous document text detection (StartDocumentTextDetection).