types

package
v1.1.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 8, 2021 License: Apache-2.0 Imports: 2 Imported by: 17

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 added in v0.29.0 

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 added in v0.29.0 

func (ContentClassifier) Values() []ContentClassifier

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 (e *DocumentTooLargeException) ErrorFault() smithy.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 added in v0.29.0 

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 added in v0.29.0 

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 (e *HumanLoopQuotaExceededException) Error() string

func (*HumanLoopQuotaExceededException) ErrorCode 

func (e *HumanLoopQuotaExceededException) ErrorCode() string

func (*HumanLoopQuotaExceededException) ErrorFault 

func (e *HumanLoopQuotaExceededException) ErrorFault() smithy.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 (e *IdempotentParameterMismatchException) Error() string

func (*IdempotentParameterMismatchException) ErrorCode 

func (e *IdempotentParameterMismatchException) ErrorCode() string

func (*IdempotentParameterMismatchException) ErrorFault 

func (e *IdempotentParameterMismatchException) ErrorFault() smithy.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 added in v0.30.0 

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 added in v0.30.0 

func (e *InvalidKMSKeyException) Error() string

func (*InvalidKMSKeyException) ErrorCode added in v0.30.0 

func (e *InvalidKMSKeyException) ErrorCode() string

func (*InvalidKMSKeyException) ErrorFault added in v0.30.0 

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

func (*InvalidKMSKeyException) ErrorMessage added in v0.30.0 

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 (e *InvalidParameterException) ErrorFault() smithy.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 added in v0.29.0 

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 added in v0.29.0 

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 (e *ProvisionedThroughputExceededException) Error() string

func (*ProvisionedThroughputExceededException) ErrorCode 

func (e *ProvisionedThroughputExceededException) ErrorCode() string

func (*ProvisionedThroughputExceededException) ErrorFault 

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

func (*ProvisionedThroughputExceededException) ErrorMessage 

func (e *ProvisionedThroughputExceededException) ErrorMessage() string

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 added in v0.29.0 

func (RelationshipType) Values() []RelationshipType

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 added in v0.29.0 

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 added in v0.30.0 

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

Enum values for TextType

func (TextType) Values added in v0.30.0 

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 (e *UnsupportedDocumentException) Error() string

func (*UnsupportedDocumentException) ErrorCode 

func (e *UnsupportedDocumentException) ErrorCode() string

func (*UnsupportedDocumentException) ErrorFault 

func (e *UnsupportedDocumentException) ErrorFault() smithy.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).

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.