xref: /dports/net/rclone/rclone-1.57.0/vendor/github.com/aws/aws-sdk-go/service/textract/api.go

// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package textract

import (
	"fmt"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/awsutil"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/private/protocol"
)

const opAnalyzeDocument = "AnalyzeDocument"

// AnalyzeDocumentRequest generates a "aws/request.Request" representing the
// client's request for the AnalyzeDocument operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See AnalyzeDocument for more information on using the AnalyzeDocument
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the AnalyzeDocumentRequest method.
//    req, resp := client.AnalyzeDocumentRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/AnalyzeDocument
func (c *Textract) AnalyzeDocumentRequest(input *AnalyzeDocumentInput) (req *request.Request, output *AnalyzeDocumentOutput) {
	op := &request.Operation{
		Name:       opAnalyzeDocument,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AnalyzeDocumentInput{}
	}

	output = &AnalyzeDocumentOutput{}
	req = c.newRequest(op, input, output)
	return
}

// AnalyzeDocument API operation for Amazon Textract.
//
// Analyzes an input document for relationships between detected items.
//
// The types of information returned are as follows:
//
//    * Form data (key-value pairs). The related information is returned in
//    two Block objects, each of type KEY_VALUE_SET: a KEY Block object and
//    a VALUE Block object. For example, Name: Ana Silva Carolina contains a
//    key and value. Name: is the key. Ana Silva Carolina is the value.
//
//    * Table and table cell data. A TABLE Block object contains information
//    about a detected table. A CELL Block object is returned for each cell
//    in a table.
//
//    * Lines and words of text. A LINE Block object contains one or more WORD
//    Block objects. All lines and words that are detected in the document are
//    returned (including text that doesn't have a relationship with the value
//    of FeatureTypes).
//
// Selection elements such as check boxes and option buttons (radio buttons)
// can be detected in form data and in tables. A SELECTION_ELEMENT Block object
// contains information about a selection element, including the selection status.
//
// You can choose which type of analysis to perform by specifying the FeatureTypes
// list.
//
// The output is returned in a list of Block objects.
//
// AnalyzeDocument is a synchronous operation. To analyze documents asynchronously,
// use StartDocumentAnalysis.
//
// For more information, see Document Text Analysis (https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Textract's
// API operation AnalyzeDocument for usage and error information.
//
// Returned Error Types:
//   * InvalidParameterException
//   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.
//
//   * InvalidS3ObjectException
//   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)
//
//   * UnsupportedDocumentException
//   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.
//
//   * DocumentTooLargeException
//   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.
//
//   * BadDocumentException
//   Amazon Textract isn't able to read the document. For more information on
//   the document limits in Amazon Textract, see limits.
//
//   * AccessDeniedException
//   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.
//
//   * ProvisionedThroughputExceededException
//   The number of requests exceeded your throughput limit. If you want to increase
//   this limit, contact Amazon Textract.
//
//   * InternalServerError
//   Amazon Textract experienced a service issue. Try your call again.
//
//   * ThrottlingException
//   Amazon Textract is temporarily unable to process the request. Try your call
//   again.
//
//   * HumanLoopQuotaExceededException
//   Indicates you have exceeded the maximum number of active human in the loop
//   workflows available
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/AnalyzeDocument
func (c *Textract) AnalyzeDocument(input *AnalyzeDocumentInput) (*AnalyzeDocumentOutput, error) {
	req, out := c.AnalyzeDocumentRequest(input)
	return out, req.Send()
}

// AnalyzeDocumentWithContext is the same as AnalyzeDocument with the addition of
// the ability to pass a context and additional request options.
//
// See AnalyzeDocument for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Textract) AnalyzeDocumentWithContext(ctx aws.Context, input *AnalyzeDocumentInput, opts ...request.Option) (*AnalyzeDocumentOutput, error) {
	req, out := c.AnalyzeDocumentRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opAnalyzeExpense = "AnalyzeExpense"

// AnalyzeExpenseRequest generates a "aws/request.Request" representing the
// client's request for the AnalyzeExpense operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See AnalyzeExpense for more information on using the AnalyzeExpense
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the AnalyzeExpenseRequest method.
//    req, resp := client.AnalyzeExpenseRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/AnalyzeExpense
func (c *Textract) AnalyzeExpenseRequest(input *AnalyzeExpenseInput) (req *request.Request, output *AnalyzeExpenseOutput) {
	op := &request.Operation{
		Name:       opAnalyzeExpense,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &AnalyzeExpenseInput{}
	}

	output = &AnalyzeExpenseOutput{}
	req = c.newRequest(op, input, output)
	return
}

// AnalyzeExpense API operation for Amazon Textract.
//
// Analyzes an input document for financially related relationships between
// text.
//
// Information is returned as ExpenseDocuments and seperated as follows.
//
//    * LineItemGroups- A data set containing LineItems which store information
//    about the lines of text, such as an item purchased and its price on a
//    receipt.
//
//    * SummaryFields- Contains all other information a receipt, such as header
//    information or the vendors name.
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Textract's
// API operation AnalyzeExpense for usage and error information.
//
// Returned Error Types:
//   * InvalidParameterException
//   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.
//
//   * InvalidS3ObjectException
//   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)
//
//   * UnsupportedDocumentException
//   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.
//
//   * DocumentTooLargeException
//   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.
//
//   * BadDocumentException
//   Amazon Textract isn't able to read the document. For more information on
//   the document limits in Amazon Textract, see limits.
//
//   * AccessDeniedException
//   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.
//
//   * ProvisionedThroughputExceededException
//   The number of requests exceeded your throughput limit. If you want to increase
//   this limit, contact Amazon Textract.
//
//   * InternalServerError
//   Amazon Textract experienced a service issue. Try your call again.
//
//   * ThrottlingException
//   Amazon Textract is temporarily unable to process the request. Try your call
//   again.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/AnalyzeExpense
func (c *Textract) AnalyzeExpense(input *AnalyzeExpenseInput) (*AnalyzeExpenseOutput, error) {
	req, out := c.AnalyzeExpenseRequest(input)
	return out, req.Send()
}

// AnalyzeExpenseWithContext is the same as AnalyzeExpense with the addition of
// the ability to pass a context and additional request options.
//
// See AnalyzeExpense for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Textract) AnalyzeExpenseWithContext(ctx aws.Context, input *AnalyzeExpenseInput, opts ...request.Option) (*AnalyzeExpenseOutput, error) {
	req, out := c.AnalyzeExpenseRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opDetectDocumentText = "DetectDocumentText"

// DetectDocumentTextRequest generates a "aws/request.Request" representing the
// client's request for the DetectDocumentText operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See DetectDocumentText for more information on using the DetectDocumentText
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the DetectDocumentTextRequest method.
//    req, resp := client.DetectDocumentTextRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/DetectDocumentText
func (c *Textract) DetectDocumentTextRequest(input *DetectDocumentTextInput) (req *request.Request, output *DetectDocumentTextOutput) {
	op := &request.Operation{
		Name:       opDetectDocumentText,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DetectDocumentTextInput{}
	}

	output = &DetectDocumentTextOutput{}
	req = c.newRequest(op, input, output)
	return
}

// DetectDocumentText API operation for Amazon Textract.
//
// Detects text in the input document. Amazon Textract can detect lines of text
// and the words that make up a line of text. The input document must be an
// image in JPEG or PNG format. DetectDocumentText returns the detected text
// in an array of Block objects.
//
// Each document page has as an associated Block of type PAGE. Each PAGE Block
// object is the parent of LINE Block objects that represent the lines of detected
// text on a page. A LINE Block object is a parent for each word that makes
// up the line. Words are represented by Block objects of type WORD.
//
// DetectDocumentText is a synchronous operation. To analyze documents asynchronously,
// use StartDocumentTextDetection.
//
// For more information, see Document Text Detection (https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Textract's
// API operation DetectDocumentText for usage and error information.
//
// Returned Error Types:
//   * InvalidParameterException
//   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.
//
//   * InvalidS3ObjectException
//   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)
//
//   * UnsupportedDocumentException
//   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.
//
//   * DocumentTooLargeException
//   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.
//
//   * BadDocumentException
//   Amazon Textract isn't able to read the document. For more information on
//   the document limits in Amazon Textract, see limits.
//
//   * AccessDeniedException
//   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.
//
//   * ProvisionedThroughputExceededException
//   The number of requests exceeded your throughput limit. If you want to increase
//   this limit, contact Amazon Textract.
//
//   * InternalServerError
//   Amazon Textract experienced a service issue. Try your call again.
//
//   * ThrottlingException
//   Amazon Textract is temporarily unable to process the request. Try your call
//   again.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/DetectDocumentText
func (c *Textract) DetectDocumentText(input *DetectDocumentTextInput) (*DetectDocumentTextOutput, error) {
	req, out := c.DetectDocumentTextRequest(input)
	return out, req.Send()
}

// DetectDocumentTextWithContext is the same as DetectDocumentText with the addition of
// the ability to pass a context and additional request options.
//
// See DetectDocumentText for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Textract) DetectDocumentTextWithContext(ctx aws.Context, input *DetectDocumentTextInput, opts ...request.Option) (*DetectDocumentTextOutput, error) {
	req, out := c.DetectDocumentTextRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opGetDocumentAnalysis = "GetDocumentAnalysis"

// GetDocumentAnalysisRequest generates a "aws/request.Request" representing the
// client's request for the GetDocumentAnalysis operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetDocumentAnalysis for more information on using the GetDocumentAnalysis
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the GetDocumentAnalysisRequest method.
//    req, resp := client.GetDocumentAnalysisRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/GetDocumentAnalysis
func (c *Textract) GetDocumentAnalysisRequest(input *GetDocumentAnalysisInput) (req *request.Request, output *GetDocumentAnalysisOutput) {
	op := &request.Operation{
		Name:       opGetDocumentAnalysis,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetDocumentAnalysisInput{}
	}

	output = &GetDocumentAnalysisOutput{}
	req = c.newRequest(op, input, output)
	return
}

// GetDocumentAnalysis API operation for Amazon Textract.
//
// Gets the results for an Amazon Textract asynchronous operation that analyzes
// text in a document.
//
// You start asynchronous text analysis by calling StartDocumentAnalysis, which
// returns a job identifier (JobId). When the text analysis operation finishes,
// Amazon Textract publishes a completion status to the Amazon Simple Notification
// Service (Amazon SNS) topic that's registered in the initial call to StartDocumentAnalysis.
// To get the results of the text-detection operation, first check that the
// status value published to the Amazon SNS topic is SUCCEEDED. If so, call
// GetDocumentAnalysis, and pass the job identifier (JobId) from the initial
// call to StartDocumentAnalysis.
//
// GetDocumentAnalysis returns an array of Block objects. The following types
// of information are returned:
//
//    * Form data (key-value pairs). The related information is returned in
//    two Block objects, each of type KEY_VALUE_SET: a KEY Block object and
//    a VALUE Block object. For example, Name: Ana Silva Carolina contains a
//    key and value. Name: is the key. Ana Silva Carolina is the value.
//
//    * Table and table cell data. A TABLE Block object contains information
//    about a detected table. A CELL Block object is returned for each cell
//    in a table.
//
//    * Lines and words of text. A LINE Block object contains one or more WORD
//    Block objects. All lines and words that are detected in the document are
//    returned (including text that doesn't have a relationship with the value
//    of the StartDocumentAnalysis FeatureTypes input parameter).
//
// Selection elements such as check boxes and option buttons (radio buttons)
// can be detected in form data and in tables. A SELECTION_ELEMENT Block object
// contains information about a selection element, including the selection status.
//
// Use the MaxResults parameter to limit the number of blocks that are returned.
// If there are more results than specified in MaxResults, the value of NextToken
// in the operation response contains a pagination token for getting the next
// set of results. To get the next page of results, call GetDocumentAnalysis,
// and populate the NextToken request parameter with the token value that's
// returned from the previous call to GetDocumentAnalysis.
//
// For more information, see Document Text Analysis (https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Textract's
// API operation GetDocumentAnalysis for usage and error information.
//
// Returned Error Types:
//   * InvalidParameterException
//   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.
//
//   * AccessDeniedException
//   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.
//
//   * ProvisionedThroughputExceededException
//   The number of requests exceeded your throughput limit. If you want to increase
//   this limit, contact Amazon Textract.
//
//   * InvalidJobIdException
//   An invalid job identifier was passed to GetDocumentAnalysis or to GetDocumentAnalysis.
//
//   * InternalServerError
//   Amazon Textract experienced a service issue. Try your call again.
//
//   * ThrottlingException
//   Amazon Textract is temporarily unable to process the request. Try your call
//   again.
//
//   * InvalidS3ObjectException
//   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)
//
//   * InvalidKMSKeyException
//   Indicates you do not have decrypt permissions with the KMS key entered, or
//   the KMS key was entered incorrectly.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/GetDocumentAnalysis
func (c *Textract) GetDocumentAnalysis(input *GetDocumentAnalysisInput) (*GetDocumentAnalysisOutput, error) {
	req, out := c.GetDocumentAnalysisRequest(input)
	return out, req.Send()
}

// GetDocumentAnalysisWithContext is the same as GetDocumentAnalysis with the addition of
// the ability to pass a context and additional request options.
//
// See GetDocumentAnalysis for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Textract) GetDocumentAnalysisWithContext(ctx aws.Context, input *GetDocumentAnalysisInput, opts ...request.Option) (*GetDocumentAnalysisOutput, error) {
	req, out := c.GetDocumentAnalysisRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opGetDocumentTextDetection = "GetDocumentTextDetection"

// GetDocumentTextDetectionRequest generates a "aws/request.Request" representing the
// client's request for the GetDocumentTextDetection operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See GetDocumentTextDetection for more information on using the GetDocumentTextDetection
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the GetDocumentTextDetectionRequest method.
//    req, resp := client.GetDocumentTextDetectionRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/GetDocumentTextDetection
func (c *Textract) GetDocumentTextDetectionRequest(input *GetDocumentTextDetectionInput) (req *request.Request, output *GetDocumentTextDetectionOutput) {
	op := &request.Operation{
		Name:       opGetDocumentTextDetection,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetDocumentTextDetectionInput{}
	}

	output = &GetDocumentTextDetectionOutput{}
	req = c.newRequest(op, input, output)
	return
}

// GetDocumentTextDetection API operation for Amazon Textract.
//
// Gets the results for an Amazon Textract asynchronous operation that detects
// text in a document. Amazon Textract can detect lines of text and the words
// that make up a line of text.
//
// You start asynchronous text detection by calling StartDocumentTextDetection,
// which returns a job identifier (JobId). When the text detection operation
// finishes, Amazon Textract publishes a completion status to the Amazon Simple
// Notification Service (Amazon SNS) topic that's registered in the initial
// call to StartDocumentTextDetection. To get the results of the text-detection
// operation, first check that the status value published to the Amazon SNS
// topic is SUCCEEDED. If so, call GetDocumentTextDetection, and pass the job
// identifier (JobId) from the initial call to StartDocumentTextDetection.
//
// GetDocumentTextDetection returns an array of Block objects.
//
// Each document page has as an associated Block of type PAGE. Each PAGE Block
// object is the parent of LINE Block objects that represent the lines of detected
// text on a page. A LINE Block object is a parent for each word that makes
// up the line. Words are represented by Block objects of type WORD.
//
// Use the MaxResults parameter to limit the number of blocks that are returned.
// If there are more results than specified in MaxResults, the value of NextToken
// in the operation response contains a pagination token for getting the next
// set of results. To get the next page of results, call GetDocumentTextDetection,
// and populate the NextToken request parameter with the token value that's
// returned from the previous call to GetDocumentTextDetection.
//
// For more information, see Document Text Detection (https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Textract's
// API operation GetDocumentTextDetection for usage and error information.
//
// Returned Error Types:
//   * InvalidParameterException
//   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.
//
//   * AccessDeniedException
//   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.
//
//   * ProvisionedThroughputExceededException
//   The number of requests exceeded your throughput limit. If you want to increase
//   this limit, contact Amazon Textract.
//
//   * InvalidJobIdException
//   An invalid job identifier was passed to GetDocumentAnalysis or to GetDocumentAnalysis.
//
//   * InternalServerError
//   Amazon Textract experienced a service issue. Try your call again.
//
//   * ThrottlingException
//   Amazon Textract is temporarily unable to process the request. Try your call
//   again.
//
//   * InvalidS3ObjectException
//   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)
//
//   * InvalidKMSKeyException
//   Indicates you do not have decrypt permissions with the KMS key entered, or
//   the KMS key was entered incorrectly.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/GetDocumentTextDetection
func (c *Textract) GetDocumentTextDetection(input *GetDocumentTextDetectionInput) (*GetDocumentTextDetectionOutput, error) {
	req, out := c.GetDocumentTextDetectionRequest(input)
	return out, req.Send()
}

// GetDocumentTextDetectionWithContext is the same as GetDocumentTextDetection with the addition of
// the ability to pass a context and additional request options.
//
// See GetDocumentTextDetection for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Textract) GetDocumentTextDetectionWithContext(ctx aws.Context, input *GetDocumentTextDetectionInput, opts ...request.Option) (*GetDocumentTextDetectionOutput, error) {
	req, out := c.GetDocumentTextDetectionRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opStartDocumentAnalysis = "StartDocumentAnalysis"

// StartDocumentAnalysisRequest generates a "aws/request.Request" representing the
// client's request for the StartDocumentAnalysis operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See StartDocumentAnalysis for more information on using the StartDocumentAnalysis
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the StartDocumentAnalysisRequest method.
//    req, resp := client.StartDocumentAnalysisRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/StartDocumentAnalysis
func (c *Textract) StartDocumentAnalysisRequest(input *StartDocumentAnalysisInput) (req *request.Request, output *StartDocumentAnalysisOutput) {
	op := &request.Operation{
		Name:       opStartDocumentAnalysis,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartDocumentAnalysisInput{}
	}

	output = &StartDocumentAnalysisOutput{}
	req = c.newRequest(op, input, output)
	return
}

// StartDocumentAnalysis API operation for Amazon Textract.
//
// Starts the asynchronous analysis of an input document for relationships between
// detected items such as key-value pairs, tables, and selection elements.
//
// StartDocumentAnalysis can analyze text in documents that are in JPEG, PNG,
// and PDF format. The documents are stored in an Amazon S3 bucket. Use DocumentLocation
// to specify the bucket name and file name of the document.
//
// StartDocumentAnalysis returns a job identifier (JobId) that you use to get
// the results of the operation. When text analysis is finished, Amazon Textract
// publishes a completion status to the Amazon Simple Notification Service (Amazon
// SNS) topic that you specify in NotificationChannel. To get the results of
// the text analysis operation, first check that the status value published
// to the Amazon SNS topic is SUCCEEDED. If so, call GetDocumentAnalysis, and
// pass the job identifier (JobId) from the initial call to StartDocumentAnalysis.
//
// For more information, see Document Text Analysis (https://docs.aws.amazon.com/textract/latest/dg/how-it-works-analyzing.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Textract's
// API operation StartDocumentAnalysis for usage and error information.
//
// Returned Error Types:
//   * InvalidParameterException
//   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.
//
//   * InvalidS3ObjectException
//   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)
//
//   * InvalidKMSKeyException
//   Indicates you do not have decrypt permissions with the KMS key entered, or
//   the KMS key was entered incorrectly.
//
//   * UnsupportedDocumentException
//   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.
//
//   * DocumentTooLargeException
//   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.
//
//   * BadDocumentException
//   Amazon Textract isn't able to read the document. For more information on
//   the document limits in Amazon Textract, see limits.
//
//   * AccessDeniedException
//   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.
//
//   * ProvisionedThroughputExceededException
//   The number of requests exceeded your throughput limit. If you want to increase
//   this limit, contact Amazon Textract.
//
//   * InternalServerError
//   Amazon Textract experienced a service issue. Try your call again.
//
//   * IdempotentParameterMismatchException
//   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.
//
//   * ThrottlingException
//   Amazon Textract is temporarily unable to process the request. Try your call
//   again.
//
//   * LimitExceededException
//   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.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/StartDocumentAnalysis
func (c *Textract) StartDocumentAnalysis(input *StartDocumentAnalysisInput) (*StartDocumentAnalysisOutput, error) {
	req, out := c.StartDocumentAnalysisRequest(input)
	return out, req.Send()
}

// StartDocumentAnalysisWithContext is the same as StartDocumentAnalysis with the addition of
// the ability to pass a context and additional request options.
//
// See StartDocumentAnalysis for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Textract) StartDocumentAnalysisWithContext(ctx aws.Context, input *StartDocumentAnalysisInput, opts ...request.Option) (*StartDocumentAnalysisOutput, error) {
	req, out := c.StartDocumentAnalysisRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

const opStartDocumentTextDetection = "StartDocumentTextDetection"

// StartDocumentTextDetectionRequest generates a "aws/request.Request" representing the
// client's request for the StartDocumentTextDetection operation. The "output" return
// value will be populated with the request's response once the request completes
// successfully.
//
// Use "Send" method on the returned Request to send the API call to the service.
// the "output" return value is not valid until after Send returns without error.
//
// See StartDocumentTextDetection for more information on using the StartDocumentTextDetection
// API call, and error handling.
//
// This method is useful when you want to inject custom logic or configuration
// into the SDK's request lifecycle. Such as custom headers, or retry logic.
//
//
//    // Example sending a request using the StartDocumentTextDetectionRequest method.
//    req, resp := client.StartDocumentTextDetectionRequest(params)
//
//    err := req.Send()
//    if err == nil { // resp is now filled
//        fmt.Println(resp)
//    }
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/StartDocumentTextDetection
func (c *Textract) StartDocumentTextDetectionRequest(input *StartDocumentTextDetectionInput) (req *request.Request, output *StartDocumentTextDetectionOutput) {
	op := &request.Operation{
		Name:       opStartDocumentTextDetection,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &StartDocumentTextDetectionInput{}
	}

	output = &StartDocumentTextDetectionOutput{}
	req = c.newRequest(op, input, output)
	return
}

// StartDocumentTextDetection API operation for Amazon Textract.
//
// Starts the asynchronous detection of text in a document. Amazon Textract
// can detect lines of text and the words that make up a line of text.
//
// StartDocumentTextDetection can analyze text in documents that are in JPEG,
// PNG, and PDF format. The documents are stored in an Amazon S3 bucket. Use
// DocumentLocation to specify the bucket name and file name of the document.
//
// StartTextDetection returns a job identifier (JobId) that you use to get the
// results of the operation. When text detection is finished, Amazon Textract
// publishes a completion status to the Amazon Simple Notification Service (Amazon
// SNS) topic that you specify in NotificationChannel. To get the results of
// the text detection operation, first check that the status value published
// to the Amazon SNS topic is SUCCEEDED. If so, call GetDocumentTextDetection,
// and pass the job identifier (JobId) from the initial call to StartDocumentTextDetection.
//
// For more information, see Document Text Detection (https://docs.aws.amazon.com/textract/latest/dg/how-it-works-detecting.html).
//
// Returns awserr.Error for service API and SDK errors. Use runtime type assertions
// with awserr.Error's Code and Message methods to get detailed information about
// the error.
//
// See the AWS API reference guide for Amazon Textract's
// API operation StartDocumentTextDetection for usage and error information.
//
// Returned Error Types:
//   * InvalidParameterException
//   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.
//
//   * InvalidS3ObjectException
//   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)
//
//   * InvalidKMSKeyException
//   Indicates you do not have decrypt permissions with the KMS key entered, or
//   the KMS key was entered incorrectly.
//
//   * UnsupportedDocumentException
//   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.
//
//   * DocumentTooLargeException
//   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.
//
//   * BadDocumentException
//   Amazon Textract isn't able to read the document. For more information on
//   the document limits in Amazon Textract, see limits.
//
//   * AccessDeniedException
//   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.
//
//   * ProvisionedThroughputExceededException
//   The number of requests exceeded your throughput limit. If you want to increase
//   this limit, contact Amazon Textract.
//
//   * InternalServerError
//   Amazon Textract experienced a service issue. Try your call again.
//
//   * IdempotentParameterMismatchException
//   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.
//
//   * ThrottlingException
//   Amazon Textract is temporarily unable to process the request. Try your call
//   again.
//
//   * LimitExceededException
//   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.
//
// See also, https://docs.aws.amazon.com/goto/WebAPI/textract-2018-06-27/StartDocumentTextDetection
func (c *Textract) StartDocumentTextDetection(input *StartDocumentTextDetectionInput) (*StartDocumentTextDetectionOutput, error) {
	req, out := c.StartDocumentTextDetectionRequest(input)
	return out, req.Send()
}

// StartDocumentTextDetectionWithContext is the same as StartDocumentTextDetection with the addition of
// the ability to pass a context and additional request options.
//
// See StartDocumentTextDetection for details on how to use this API operation.
//
// The context must be non-nil and will be used for request cancellation. If
// the context is nil a panic will occur. In the future the SDK may create
// sub-contexts for http.Requests. See https://golang.org/pkg/context/
// for more information on using Contexts.
func (c *Textract) StartDocumentTextDetectionWithContext(ctx aws.Context, input *StartDocumentTextDetectionInput, opts ...request.Option) (*StartDocumentTextDetectionOutput, error) {
	req, out := c.StartDocumentTextDetectionRequest(input)
	req.SetContext(ctx)
	req.ApplyOptions(opts...)
	return out, req.Send()
}

// 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.
type AccessDeniedException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s AccessDeniedException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AccessDeniedException) GoString() string {
	return s.String()
}

func newErrorAccessDeniedException(v protocol.ResponseMetadata) error {
	return &AccessDeniedException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *AccessDeniedException) Code() string {
	return "AccessDeniedException"
}

// Message returns the exception's message.
func (s *AccessDeniedException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *AccessDeniedException) OrigErr() error {
	return nil
}

func (s *AccessDeniedException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *AccessDeniedException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *AccessDeniedException) RequestID() string {
	return s.RespMetadata.RequestID
}

type AnalyzeDocumentInput struct {
	_ struct{} `type:"structure"`

	// The input document as base64-encoded bytes or an Amazon S3 object. If you
	// use the AWS CLI to call Amazon Textract operations, you can't pass image
	// bytes. The document must be an image in JPEG or PNG format.
	//
	// If you're using an AWS SDK to call Amazon Textract, you might not need to
	// base64-encode image bytes that are passed using the Bytes field.
	//
	// Document is a required field
	Document *Document `type:"structure" required:"true"`

	// A list of the types of analysis to perform. Add TABLES to the list to return
	// information about the tables that are detected in the input document. Add
	// FORMS to return detected form data. To perform both types of analysis, add
	// TABLES and FORMS to FeatureTypes. All lines and words detected in the document
	// are included in the response (including text that isn't related to the value
	// of FeatureTypes).
	//
	// FeatureTypes is a required field
	FeatureTypes []*string `type:"list" required:"true"`

	// Sets the configuration for the human in the loop workflow for analyzing documents.
	HumanLoopConfig *HumanLoopConfig `type:"structure"`
}

// String returns the string representation
func (s AnalyzeDocumentInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AnalyzeDocumentInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AnalyzeDocumentInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AnalyzeDocumentInput"}
	if s.Document == nil {
		invalidParams.Add(request.NewErrParamRequired("Document"))
	}
	if s.FeatureTypes == nil {
		invalidParams.Add(request.NewErrParamRequired("FeatureTypes"))
	}
	if s.Document != nil {
		if err := s.Document.Validate(); err != nil {
			invalidParams.AddNested("Document", err.(request.ErrInvalidParams))
		}
	}
	if s.HumanLoopConfig != nil {
		if err := s.HumanLoopConfig.Validate(); err != nil {
			invalidParams.AddNested("HumanLoopConfig", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetDocument sets the Document field's value.
func (s *AnalyzeDocumentInput) SetDocument(v *Document) *AnalyzeDocumentInput {
	s.Document = v
	return s
}

// SetFeatureTypes sets the FeatureTypes field's value.
func (s *AnalyzeDocumentInput) SetFeatureTypes(v []*string) *AnalyzeDocumentInput {
	s.FeatureTypes = v
	return s
}

// SetHumanLoopConfig sets the HumanLoopConfig field's value.
func (s *AnalyzeDocumentInput) SetHumanLoopConfig(v *HumanLoopConfig) *AnalyzeDocumentInput {
	s.HumanLoopConfig = v
	return s
}

type AnalyzeDocumentOutput struct {
	_ struct{} `type:"structure"`

	// The version of the model used to analyze the document.
	AnalyzeDocumentModelVersion *string `type:"string"`

	// The items that are detected and analyzed by AnalyzeDocument.
	Blocks []*Block `type:"list"`

	// Metadata about the analyzed document. An example is the number of pages.
	DocumentMetadata *DocumentMetadata `type:"structure"`

	// Shows the results of the human in the loop evaluation.
	HumanLoopActivationOutput *HumanLoopActivationOutput `type:"structure"`
}

// String returns the string representation
func (s AnalyzeDocumentOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AnalyzeDocumentOutput) GoString() string {
	return s.String()
}

// SetAnalyzeDocumentModelVersion sets the AnalyzeDocumentModelVersion field's value.
func (s *AnalyzeDocumentOutput) SetAnalyzeDocumentModelVersion(v string) *AnalyzeDocumentOutput {
	s.AnalyzeDocumentModelVersion = &v
	return s
}

// SetBlocks sets the Blocks field's value.
func (s *AnalyzeDocumentOutput) SetBlocks(v []*Block) *AnalyzeDocumentOutput {
	s.Blocks = v
	return s
}

// SetDocumentMetadata sets the DocumentMetadata field's value.
func (s *AnalyzeDocumentOutput) SetDocumentMetadata(v *DocumentMetadata) *AnalyzeDocumentOutput {
	s.DocumentMetadata = v
	return s
}

// SetHumanLoopActivationOutput sets the HumanLoopActivationOutput field's value.
func (s *AnalyzeDocumentOutput) SetHumanLoopActivationOutput(v *HumanLoopActivationOutput) *AnalyzeDocumentOutput {
	s.HumanLoopActivationOutput = v
	return s
}

type AnalyzeExpenseInput struct {
	_ struct{} `type:"structure"`

	// 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.
	//
	// Document is a required field
	Document *Document `type:"structure" required:"true"`
}

// String returns the string representation
func (s AnalyzeExpenseInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AnalyzeExpenseInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *AnalyzeExpenseInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "AnalyzeExpenseInput"}
	if s.Document == nil {
		invalidParams.Add(request.NewErrParamRequired("Document"))
	}
	if s.Document != nil {
		if err := s.Document.Validate(); err != nil {
			invalidParams.AddNested("Document", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetDocument sets the Document field's value.
func (s *AnalyzeExpenseInput) SetDocument(v *Document) *AnalyzeExpenseInput {
	s.Document = v
	return s
}

type AnalyzeExpenseOutput struct {
	_ struct{} `type:"structure"`

	// Information about the input document.
	DocumentMetadata *DocumentMetadata `type:"structure"`

	// The expenses detected by Amazon Textract.
	ExpenseDocuments []*ExpenseDocument `type:"list"`
}

// String returns the string representation
func (s AnalyzeExpenseOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s AnalyzeExpenseOutput) GoString() string {
	return s.String()
}

// SetDocumentMetadata sets the DocumentMetadata field's value.
func (s *AnalyzeExpenseOutput) SetDocumentMetadata(v *DocumentMetadata) *AnalyzeExpenseOutput {
	s.DocumentMetadata = v
	return s
}

// SetExpenseDocuments sets the ExpenseDocuments field's value.
func (s *AnalyzeExpenseOutput) SetExpenseDocuments(v []*ExpenseDocument) *AnalyzeExpenseOutput {
	s.ExpenseDocuments = v
	return s
}

// Amazon Textract isn't able to read the document. For more information on
// the document limits in Amazon Textract, see limits.
type BadDocumentException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s BadDocumentException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s BadDocumentException) GoString() string {
	return s.String()
}

func newErrorBadDocumentException(v protocol.ResponseMetadata) error {
	return &BadDocumentException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *BadDocumentException) Code() string {
	return "BadDocumentException"
}

// Message returns the exception's message.
func (s *BadDocumentException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *BadDocumentException) OrigErr() error {
	return nil
}

func (s *BadDocumentException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *BadDocumentException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *BadDocumentException) RequestID() string {
	return s.RespMetadata.RequestID
}

// 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 Block struct {
	_ struct{} `type:"structure"`

	// 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 *string `type:"string" enum:"BlockType"`

	// The column in which a table cell appears. The first column position is 1.
	// ColumnIndex isn't returned by DetectDocumentText and GetDocumentTextDetection.
	ColumnIndex *int64 `type:"integer"`

	// 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 *int64 `type:"integer"`

	// 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 *float64 `type:"float"`

	// 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 []*string `type:"list"`

	// 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 `type:"structure"`

	// The identifier for the recognized text. The identifier is only unique for
	// a single operation.
	Id *string `type:"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 *int64 `type:"integer"`

	// 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 `type:"list"`

	// The row in which a table cell is located. The first row position is 1. RowIndex
	// isn't returned by DetectDocumentText and GetDocumentTextDetection.
	RowIndex *int64 `type:"integer"`

	// 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 *int64 `type:"integer"`

	// The selection status of a selection element, such as an option button or
	// check box.
	SelectionStatus *string `type:"string" enum:"SelectionStatus"`

	// The word or line of text that's recognized by Amazon Textract.
	Text *string `type:"string"`

	// The kind of text that Amazon Textract has detected. Can check for handwritten
	// text and printed text.
	TextType *string `type:"string" enum:"TextType"`
}

// String returns the string representation
func (s Block) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Block) GoString() string {
	return s.String()
}

// SetBlockType sets the BlockType field's value.
func (s *Block) SetBlockType(v string) *Block {
	s.BlockType = &v
	return s
}

// SetColumnIndex sets the ColumnIndex field's value.
func (s *Block) SetColumnIndex(v int64) *Block {
	s.ColumnIndex = &v
	return s
}

// SetColumnSpan sets the ColumnSpan field's value.
func (s *Block) SetColumnSpan(v int64) *Block {
	s.ColumnSpan = &v
	return s
}

// SetConfidence sets the Confidence field's value.
func (s *Block) SetConfidence(v float64) *Block {
	s.Confidence = &v
	return s
}

// SetEntityTypes sets the EntityTypes field's value.
func (s *Block) SetEntityTypes(v []*string) *Block {
	s.EntityTypes = v
	return s
}

// SetGeometry sets the Geometry field's value.
func (s *Block) SetGeometry(v *Geometry) *Block {
	s.Geometry = v
	return s
}

// SetId sets the Id field's value.
func (s *Block) SetId(v string) *Block {
	s.Id = &v
	return s
}

// SetPage sets the Page field's value.
func (s *Block) SetPage(v int64) *Block {
	s.Page = &v
	return s
}

// SetRelationships sets the Relationships field's value.
func (s *Block) SetRelationships(v []*Relationship) *Block {
	s.Relationships = v
	return s
}

// SetRowIndex sets the RowIndex field's value.
func (s *Block) SetRowIndex(v int64) *Block {
	s.RowIndex = &v
	return s
}

// SetRowSpan sets the RowSpan field's value.
func (s *Block) SetRowSpan(v int64) *Block {
	s.RowSpan = &v
	return s
}

// SetSelectionStatus sets the SelectionStatus field's value.
func (s *Block) SetSelectionStatus(v string) *Block {
	s.SelectionStatus = &v
	return s
}

// SetText sets the Text field's value.
func (s *Block) SetText(v string) *Block {
	s.Text = &v
	return s
}

// SetTextType sets the TextType field's value.
func (s *Block) SetTextType(v string) *Block {
	s.TextType = &v
	return s
}

// 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 BoundingBox struct {
	_ struct{} `type:"structure"`

	// The height of the bounding box as a ratio of the overall document page height.
	Height *float64 `type:"float"`

	// The left coordinate of the bounding box as a ratio of overall document page
	// width.
	Left *float64 `type:"float"`

	// The top coordinate of the bounding box as a ratio of overall document page
	// height.
	Top *float64 `type:"float"`

	// The width of the bounding box as a ratio of the overall document page width.
	Width *float64 `type:"float"`
}

// String returns the string representation
func (s BoundingBox) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s BoundingBox) GoString() string {
	return s.String()
}

// SetHeight sets the Height field's value.
func (s *BoundingBox) SetHeight(v float64) *BoundingBox {
	s.Height = &v
	return s
}

// SetLeft sets the Left field's value.
func (s *BoundingBox) SetLeft(v float64) *BoundingBox {
	s.Left = &v
	return s
}

// SetTop sets the Top field's value.
func (s *BoundingBox) SetTop(v float64) *BoundingBox {
	s.Top = &v
	return s
}

// SetWidth sets the Width field's value.
func (s *BoundingBox) SetWidth(v float64) *BoundingBox {
	s.Width = &v
	return s
}

type DetectDocumentTextInput struct {
	_ struct{} `type:"structure"`

	// The input document as base64-encoded bytes or an Amazon S3 object. If you
	// use the AWS CLI to call Amazon Textract operations, you can't pass image
	// bytes. The document must be an image in JPEG or PNG format.
	//
	// If you're using an AWS SDK to call Amazon Textract, you might not need to
	// base64-encode image bytes that are passed using the Bytes field.
	//
	// Document is a required field
	Document *Document `type:"structure" required:"true"`
}

// String returns the string representation
func (s DetectDocumentTextInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DetectDocumentTextInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DetectDocumentTextInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "DetectDocumentTextInput"}
	if s.Document == nil {
		invalidParams.Add(request.NewErrParamRequired("Document"))
	}
	if s.Document != nil {
		if err := s.Document.Validate(); err != nil {
			invalidParams.AddNested("Document", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetDocument sets the Document field's value.
func (s *DetectDocumentTextInput) SetDocument(v *Document) *DetectDocumentTextInput {
	s.Document = v
	return s
}

type DetectDocumentTextOutput struct {
	_ struct{} `type:"structure"`

	// An array of Block objects that contain the text that's detected in the document.
	Blocks []*Block `type:"list"`

	DetectDocumentTextModelVersion *string `type:"string"`

	// Metadata about the document. It contains the number of pages that are detected
	// in the document.
	DocumentMetadata *DocumentMetadata `type:"structure"`
}

// String returns the string representation
func (s DetectDocumentTextOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DetectDocumentTextOutput) GoString() string {
	return s.String()
}

// SetBlocks sets the Blocks field's value.
func (s *DetectDocumentTextOutput) SetBlocks(v []*Block) *DetectDocumentTextOutput {
	s.Blocks = v
	return s
}

// SetDetectDocumentTextModelVersion sets the DetectDocumentTextModelVersion field's value.
func (s *DetectDocumentTextOutput) SetDetectDocumentTextModelVersion(v string) *DetectDocumentTextOutput {
	s.DetectDocumentTextModelVersion = &v
	return s
}

// SetDocumentMetadata sets the DocumentMetadata field's value.
func (s *DetectDocumentTextOutput) SetDocumentMetadata(v *DocumentMetadata) *DetectDocumentTextOutput {
	s.DocumentMetadata = v
	return s
}

// 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 Document struct {
	_ struct{} `type:"structure"`

	// 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 is automatically base64 encoded/decoded by the SDK.
	Bytes []byte `min:"1" type:"blob"`

	// 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 `type:"structure"`
}

// String returns the string representation
func (s Document) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Document) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Document) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "Document"}
	if s.Bytes != nil && len(s.Bytes) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Bytes", 1))
	}
	if s.S3Object != nil {
		if err := s.S3Object.Validate(); err != nil {
			invalidParams.AddNested("S3Object", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetBytes sets the Bytes field's value.
func (s *Document) SetBytes(v []byte) *Document {
	s.Bytes = v
	return s
}

// SetS3Object sets the S3Object field's value.
func (s *Document) SetS3Object(v *S3Object) *Document {
	s.S3Object = v
	return s
}

// 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 DocumentLocation struct {
	_ struct{} `type:"structure"`

	// The Amazon S3 bucket that contains the input document.
	S3Object *S3Object `type:"structure"`
}

// String returns the string representation
func (s DocumentLocation) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DocumentLocation) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DocumentLocation) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "DocumentLocation"}
	if s.S3Object != nil {
		if err := s.S3Object.Validate(); err != nil {
			invalidParams.AddNested("S3Object", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetS3Object sets the S3Object field's value.
func (s *DocumentLocation) SetS3Object(v *S3Object) *DocumentLocation {
	s.S3Object = v
	return s
}

// Information about the input document.
type DocumentMetadata struct {
	_ struct{} `type:"structure"`

	// The number of pages that are detected in the document.
	Pages *int64 `type:"integer"`
}

// String returns the string representation
func (s DocumentMetadata) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DocumentMetadata) GoString() string {
	return s.String()
}

// SetPages sets the Pages field's value.
func (s *DocumentMetadata) SetPages(v int64) *DocumentMetadata {
	s.Pages = &v
	return s
}

// 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.
type DocumentTooLargeException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s DocumentTooLargeException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DocumentTooLargeException) GoString() string {
	return s.String()
}

func newErrorDocumentTooLargeException(v protocol.ResponseMetadata) error {
	return &DocumentTooLargeException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *DocumentTooLargeException) Code() string {
	return "DocumentTooLargeException"
}

// Message returns the exception's message.
func (s *DocumentTooLargeException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *DocumentTooLargeException) OrigErr() error {
	return nil
}

func (s *DocumentTooLargeException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *DocumentTooLargeException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *DocumentTooLargeException) RequestID() string {
	return s.RespMetadata.RequestID
}

// An object used to store information about the Value or Label detected by
// Amazon Textract.
type ExpenseDetection struct {
	_ struct{} `type:"structure"`

	// The confidence in detection, as a percentage
	Confidence *float64 `type:"float"`

	// Information about where the following items are located on a document page:
	// detected page, text, key-value pairs, tables, table cells, and selection
	// elements.
	Geometry *Geometry `type:"structure"`

	// The word or line of text recognized by Amazon Textract
	Text *string `type:"string"`
}

// String returns the string representation
func (s ExpenseDetection) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ExpenseDetection) GoString() string {
	return s.String()
}

// SetConfidence sets the Confidence field's value.
func (s *ExpenseDetection) SetConfidence(v float64) *ExpenseDetection {
	s.Confidence = &v
	return s
}

// SetGeometry sets the Geometry field's value.
func (s *ExpenseDetection) SetGeometry(v *Geometry) *ExpenseDetection {
	s.Geometry = v
	return s
}

// SetText sets the Text field's value.
func (s *ExpenseDetection) SetText(v string) *ExpenseDetection {
	s.Text = &v
	return s
}

// The structure holding all the information returned by AnalyzeExpense
type ExpenseDocument struct {
	_ struct{} `type:"structure"`

	// Denotes which invoice or receipt in the document the information is coming
	// from. First document will be 1, the second 2, and so on.
	ExpenseIndex *int64 `type:"integer"`

	// Information detected on each table of a document, seperated into LineItems.
	LineItemGroups []*LineItemGroup `type:"list"`

	// Any information found outside of a table by Amazon Textract.
	SummaryFields []*ExpenseField `type:"list"`
}

// String returns the string representation
func (s ExpenseDocument) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ExpenseDocument) GoString() string {
	return s.String()
}

// SetExpenseIndex sets the ExpenseIndex field's value.
func (s *ExpenseDocument) SetExpenseIndex(v int64) *ExpenseDocument {
	s.ExpenseIndex = &v
	return s
}

// SetLineItemGroups sets the LineItemGroups field's value.
func (s *ExpenseDocument) SetLineItemGroups(v []*LineItemGroup) *ExpenseDocument {
	s.LineItemGroups = v
	return s
}

// SetSummaryFields sets the SummaryFields field's value.
func (s *ExpenseDocument) SetSummaryFields(v []*ExpenseField) *ExpenseDocument {
	s.SummaryFields = v
	return s
}

// Breakdown of detected information, seperated into the catagories Type, LableDetection,
// and ValueDetection
type ExpenseField struct {
	_ struct{} `type:"structure"`

	// The explicitly stated label of a detected element.
	LabelDetection *ExpenseDetection `type:"structure"`

	// The page number the value was detected on.
	PageNumber *int64 `type:"integer"`

	// The implied label of a detected element. Present alongside LabelDetection
	// for explicit elements.
	Type *ExpenseType `type:"structure"`

	// The value of a detected element. Present in explicit and implicit elements.
	ValueDetection *ExpenseDetection `type:"structure"`
}

// String returns the string representation
func (s ExpenseField) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ExpenseField) GoString() string {
	return s.String()
}

// SetLabelDetection sets the LabelDetection field's value.
func (s *ExpenseField) SetLabelDetection(v *ExpenseDetection) *ExpenseField {
	s.LabelDetection = v
	return s
}

// SetPageNumber sets the PageNumber field's value.
func (s *ExpenseField) SetPageNumber(v int64) *ExpenseField {
	s.PageNumber = &v
	return s
}

// SetType sets the Type field's value.
func (s *ExpenseField) SetType(v *ExpenseType) *ExpenseField {
	s.Type = v
	return s
}

// SetValueDetection sets the ValueDetection field's value.
func (s *ExpenseField) SetValueDetection(v *ExpenseDetection) *ExpenseField {
	s.ValueDetection = v
	return s
}

// An object used to store information about the Type detected by Amazon Textract.
type ExpenseType struct {
	_ struct{} `type:"structure"`

	// The confidence of accuracy, as a percentage.
	Confidence *float64 `type:"float"`

	// The word or line of text detected by Amazon Textract.
	Text *string `type:"string"`
}

// String returns the string representation
func (s ExpenseType) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ExpenseType) GoString() string {
	return s.String()
}

// SetConfidence sets the Confidence field's value.
func (s *ExpenseType) SetConfidence(v float64) *ExpenseType {
	s.Confidence = &v
	return s
}

// SetText sets the Text field's value.
func (s *ExpenseType) SetText(v string) *ExpenseType {
	s.Text = &v
	return s
}

// 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 Geometry struct {
	_ struct{} `type:"structure"`

	// An axis-aligned coarse representation of the location of the recognized item
	// on the document page.
	BoundingBox *BoundingBox `type:"structure"`

	// Within the bounding box, a fine-grained polygon around the recognized item.
	Polygon []*Point `type:"list"`
}

// String returns the string representation
func (s Geometry) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Geometry) GoString() string {
	return s.String()
}

// SetBoundingBox sets the BoundingBox field's value.
func (s *Geometry) SetBoundingBox(v *BoundingBox) *Geometry {
	s.BoundingBox = v
	return s
}

// SetPolygon sets the Polygon field's value.
func (s *Geometry) SetPolygon(v []*Point) *Geometry {
	s.Polygon = v
	return s
}

type GetDocumentAnalysisInput struct {
	_ struct{} `type:"structure"`

	// A unique identifier for the text-detection job. The JobId is returned from
	// StartDocumentAnalysis. A JobId value is only valid for 7 days.
	//
	// JobId is a required field
	JobId *string `min:"1" type:"string" required:"true"`

	// The maximum number of results to return per paginated call. The largest value
	// that you can specify is 1,000. If you specify a value greater than 1,000,
	// a maximum of 1,000 results is returned. The default value is 1,000.
	MaxResults *int64 `min:"1" type:"integer"`

	// If the previous response was incomplete (because there are more blocks to
	// retrieve), Amazon Textract returns a pagination token in the response. You
	// can use this pagination token to retrieve the next set of blocks.
	NextToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s GetDocumentAnalysisInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetDocumentAnalysisInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetDocumentAnalysisInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "GetDocumentAnalysisInput"}
	if s.JobId == nil {
		invalidParams.Add(request.NewErrParamRequired("JobId"))
	}
	if s.JobId != nil && len(*s.JobId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("JobId", 1))
	}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
	}
	if s.NextToken != nil && len(*s.NextToken) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetJobId sets the JobId field's value.
func (s *GetDocumentAnalysisInput) SetJobId(v string) *GetDocumentAnalysisInput {
	s.JobId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *GetDocumentAnalysisInput) SetMaxResults(v int64) *GetDocumentAnalysisInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *GetDocumentAnalysisInput) SetNextToken(v string) *GetDocumentAnalysisInput {
	s.NextToken = &v
	return s
}

type GetDocumentAnalysisOutput struct {
	_ struct{} `type:"structure"`

	AnalyzeDocumentModelVersion *string `type:"string"`

	// The results of the text-analysis operation.
	Blocks []*Block `type:"list"`

	// Information about a document that Amazon Textract processed. DocumentMetadata
	// is returned in every page of paginated responses from an Amazon Textract
	// video operation.
	DocumentMetadata *DocumentMetadata `type:"structure"`

	// The current status of the text detection job.
	JobStatus *string `type:"string" enum:"JobStatus"`

	// If the response is truncated, Amazon Textract returns this token. You can
	// use this token in the subsequent request to retrieve the next set of text
	// detection results.
	NextToken *string `min:"1" type:"string"`

	// Returns if the detection job could not be completed. Contains explanation
	// for what error occured.
	StatusMessage *string `type:"string"`

	// A list of warnings that occurred during the document-analysis operation.
	Warnings []*Warning `type:"list"`
}

// String returns the string representation
func (s GetDocumentAnalysisOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetDocumentAnalysisOutput) GoString() string {
	return s.String()
}

// SetAnalyzeDocumentModelVersion sets the AnalyzeDocumentModelVersion field's value.
func (s *GetDocumentAnalysisOutput) SetAnalyzeDocumentModelVersion(v string) *GetDocumentAnalysisOutput {
	s.AnalyzeDocumentModelVersion = &v
	return s
}

// SetBlocks sets the Blocks field's value.
func (s *GetDocumentAnalysisOutput) SetBlocks(v []*Block) *GetDocumentAnalysisOutput {
	s.Blocks = v
	return s
}

// SetDocumentMetadata sets the DocumentMetadata field's value.
func (s *GetDocumentAnalysisOutput) SetDocumentMetadata(v *DocumentMetadata) *GetDocumentAnalysisOutput {
	s.DocumentMetadata = v
	return s
}

// SetJobStatus sets the JobStatus field's value.
func (s *GetDocumentAnalysisOutput) SetJobStatus(v string) *GetDocumentAnalysisOutput {
	s.JobStatus = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *GetDocumentAnalysisOutput) SetNextToken(v string) *GetDocumentAnalysisOutput {
	s.NextToken = &v
	return s
}

// SetStatusMessage sets the StatusMessage field's value.
func (s *GetDocumentAnalysisOutput) SetStatusMessage(v string) *GetDocumentAnalysisOutput {
	s.StatusMessage = &v
	return s
}

// SetWarnings sets the Warnings field's value.
func (s *GetDocumentAnalysisOutput) SetWarnings(v []*Warning) *GetDocumentAnalysisOutput {
	s.Warnings = v
	return s
}

type GetDocumentTextDetectionInput struct {
	_ struct{} `type:"structure"`

	// A unique identifier for the text detection job. The JobId is returned from
	// StartDocumentTextDetection. A JobId value is only valid for 7 days.
	//
	// JobId is a required field
	JobId *string `min:"1" type:"string" required:"true"`

	// The maximum number of results to return per paginated call. The largest value
	// you can specify is 1,000. If you specify a value greater than 1,000, a maximum
	// of 1,000 results is returned. The default value is 1,000.
	MaxResults *int64 `min:"1" type:"integer"`

	// If the previous response was incomplete (because there are more blocks to
	// retrieve), Amazon Textract returns a pagination token in the response. You
	// can use this pagination token to retrieve the next set of blocks.
	NextToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s GetDocumentTextDetectionInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetDocumentTextDetectionInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetDocumentTextDetectionInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "GetDocumentTextDetectionInput"}
	if s.JobId == nil {
		invalidParams.Add(request.NewErrParamRequired("JobId"))
	}
	if s.JobId != nil && len(*s.JobId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("JobId", 1))
	}
	if s.MaxResults != nil && *s.MaxResults < 1 {
		invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1))
	}
	if s.NextToken != nil && len(*s.NextToken) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("NextToken", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetJobId sets the JobId field's value.
func (s *GetDocumentTextDetectionInput) SetJobId(v string) *GetDocumentTextDetectionInput {
	s.JobId = &v
	return s
}

// SetMaxResults sets the MaxResults field's value.
func (s *GetDocumentTextDetectionInput) SetMaxResults(v int64) *GetDocumentTextDetectionInput {
	s.MaxResults = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *GetDocumentTextDetectionInput) SetNextToken(v string) *GetDocumentTextDetectionInput {
	s.NextToken = &v
	return s
}

type GetDocumentTextDetectionOutput struct {
	_ struct{} `type:"structure"`

	// The results of the text-detection operation.
	Blocks []*Block `type:"list"`

	DetectDocumentTextModelVersion *string `type:"string"`

	// Information about a document that Amazon Textract processed. DocumentMetadata
	// is returned in every page of paginated responses from an Amazon Textract
	// video operation.
	DocumentMetadata *DocumentMetadata `type:"structure"`

	// The current status of the text detection job.
	JobStatus *string `type:"string" enum:"JobStatus"`

	// If the response is truncated, Amazon Textract returns this token. You can
	// use this token in the subsequent request to retrieve the next set of text-detection
	// results.
	NextToken *string `min:"1" type:"string"`

	// Returns if the detection job could not be completed. Contains explanation
	// for what error occured.
	StatusMessage *string `type:"string"`

	// A list of warnings that occurred during the text-detection operation for
	// the document.
	Warnings []*Warning `type:"list"`
}

// String returns the string representation
func (s GetDocumentTextDetectionOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetDocumentTextDetectionOutput) GoString() string {
	return s.String()
}

// SetBlocks sets the Blocks field's value.
func (s *GetDocumentTextDetectionOutput) SetBlocks(v []*Block) *GetDocumentTextDetectionOutput {
	s.Blocks = v
	return s
}

// SetDetectDocumentTextModelVersion sets the DetectDocumentTextModelVersion field's value.
func (s *GetDocumentTextDetectionOutput) SetDetectDocumentTextModelVersion(v string) *GetDocumentTextDetectionOutput {
	s.DetectDocumentTextModelVersion = &v
	return s
}

// SetDocumentMetadata sets the DocumentMetadata field's value.
func (s *GetDocumentTextDetectionOutput) SetDocumentMetadata(v *DocumentMetadata) *GetDocumentTextDetectionOutput {
	s.DocumentMetadata = v
	return s
}

// SetJobStatus sets the JobStatus field's value.
func (s *GetDocumentTextDetectionOutput) SetJobStatus(v string) *GetDocumentTextDetectionOutput {
	s.JobStatus = &v
	return s
}

// SetNextToken sets the NextToken field's value.
func (s *GetDocumentTextDetectionOutput) SetNextToken(v string) *GetDocumentTextDetectionOutput {
	s.NextToken = &v
	return s
}

// SetStatusMessage sets the StatusMessage field's value.
func (s *GetDocumentTextDetectionOutput) SetStatusMessage(v string) *GetDocumentTextDetectionOutput {
	s.StatusMessage = &v
	return s
}

// SetWarnings sets the Warnings field's value.
func (s *GetDocumentTextDetectionOutput) SetWarnings(v []*Warning) *GetDocumentTextDetectionOutput {
	s.Warnings = v
	return s
}

// Shows the results of the human in the loop evaluation. If there is no HumanLoopArn,
// the input did not trigger human review.
type HumanLoopActivationOutput struct {
	_ struct{} `type:"structure"`

	// Shows the result of condition evaluations, including those conditions which
	// activated a human review.
	HumanLoopActivationConditionsEvaluationResults aws.JSONValue `type:"jsonvalue"`

	// Shows if and why human review was needed.
	HumanLoopActivationReasons []*string `min:"1" type:"list"`

	// The Amazon Resource Name (ARN) of the HumanLoop created.
	HumanLoopArn *string `type:"string"`
}

// String returns the string representation
func (s HumanLoopActivationOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s HumanLoopActivationOutput) GoString() string {
	return s.String()
}

// SetHumanLoopActivationConditionsEvaluationResults sets the HumanLoopActivationConditionsEvaluationResults field's value.
func (s *HumanLoopActivationOutput) SetHumanLoopActivationConditionsEvaluationResults(v aws.JSONValue) *HumanLoopActivationOutput {
	s.HumanLoopActivationConditionsEvaluationResults = v
	return s
}

// SetHumanLoopActivationReasons sets the HumanLoopActivationReasons field's value.
func (s *HumanLoopActivationOutput) SetHumanLoopActivationReasons(v []*string) *HumanLoopActivationOutput {
	s.HumanLoopActivationReasons = v
	return s
}

// SetHumanLoopArn sets the HumanLoopArn field's value.
func (s *HumanLoopActivationOutput) SetHumanLoopArn(v string) *HumanLoopActivationOutput {
	s.HumanLoopArn = &v
	return s
}

// 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 HumanLoopConfig struct {
	_ struct{} `type:"structure"`

	// Sets attributes of the input data.
	DataAttributes *HumanLoopDataAttributes `type:"structure"`

	// The Amazon Resource Name (ARN) of the flow definition.
	//
	// FlowDefinitionArn is a required field
	FlowDefinitionArn *string `type:"string" required:"true"`

	// The name of the human workflow used for this image. This should be kept unique
	// within a region.
	//
	// HumanLoopName is a required field
	HumanLoopName *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s HumanLoopConfig) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s HumanLoopConfig) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *HumanLoopConfig) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "HumanLoopConfig"}
	if s.FlowDefinitionArn == nil {
		invalidParams.Add(request.NewErrParamRequired("FlowDefinitionArn"))
	}
	if s.HumanLoopName == nil {
		invalidParams.Add(request.NewErrParamRequired("HumanLoopName"))
	}
	if s.HumanLoopName != nil && len(*s.HumanLoopName) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("HumanLoopName", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetDataAttributes sets the DataAttributes field's value.
func (s *HumanLoopConfig) SetDataAttributes(v *HumanLoopDataAttributes) *HumanLoopConfig {
	s.DataAttributes = v
	return s
}

// SetFlowDefinitionArn sets the FlowDefinitionArn field's value.
func (s *HumanLoopConfig) SetFlowDefinitionArn(v string) *HumanLoopConfig {
	s.FlowDefinitionArn = &v
	return s
}

// SetHumanLoopName sets the HumanLoopName field's value.
func (s *HumanLoopConfig) SetHumanLoopName(v string) *HumanLoopConfig {
	s.HumanLoopName = &v
	return s
}

// Allows you to set attributes of the image. Currently, you can declare an
// image as free of personally identifiable information and adult content.
type HumanLoopDataAttributes struct {
	_ struct{} `type:"structure"`

	// Sets whether the input image is free of personally identifiable information
	// or adult content.
	ContentClassifiers []*string `type:"list"`
}

// String returns the string representation
func (s HumanLoopDataAttributes) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s HumanLoopDataAttributes) GoString() string {
	return s.String()
}

// SetContentClassifiers sets the ContentClassifiers field's value.
func (s *HumanLoopDataAttributes) SetContentClassifiers(v []*string) *HumanLoopDataAttributes {
	s.ContentClassifiers = v
	return s
}

// Indicates you have exceeded the maximum number of active human in the loop
// workflows available
type HumanLoopQuotaExceededException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`

	// The quota code.
	QuotaCode *string `type:"string"`

	// The resource type.
	ResourceType *string `type:"string"`

	// The service code.
	ServiceCode *string `type:"string"`
}

// String returns the string representation
func (s HumanLoopQuotaExceededException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s HumanLoopQuotaExceededException) GoString() string {
	return s.String()
}

func newErrorHumanLoopQuotaExceededException(v protocol.ResponseMetadata) error {
	return &HumanLoopQuotaExceededException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *HumanLoopQuotaExceededException) Code() string {
	return "HumanLoopQuotaExceededException"
}

// Message returns the exception's message.
func (s *HumanLoopQuotaExceededException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *HumanLoopQuotaExceededException) OrigErr() error {
	return nil
}

func (s *HumanLoopQuotaExceededException) Error() string {
	return fmt.Sprintf("%s: %s\n%s", s.Code(), s.Message(), s.String())
}

// Status code returns the HTTP status code for the request's response error.
func (s *HumanLoopQuotaExceededException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *HumanLoopQuotaExceededException) RequestID() string {
	return s.RespMetadata.RequestID
}

// 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.
type IdempotentParameterMismatchException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s IdempotentParameterMismatchException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s IdempotentParameterMismatchException) GoString() string {
	return s.String()
}

func newErrorIdempotentParameterMismatchException(v protocol.ResponseMetadata) error {
	return &IdempotentParameterMismatchException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *IdempotentParameterMismatchException) Code() string {
	return "IdempotentParameterMismatchException"
}

// Message returns the exception's message.
func (s *IdempotentParameterMismatchException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *IdempotentParameterMismatchException) OrigErr() error {
	return nil
}

func (s *IdempotentParameterMismatchException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *IdempotentParameterMismatchException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *IdempotentParameterMismatchException) RequestID() string {
	return s.RespMetadata.RequestID
}

// Amazon Textract experienced a service issue. Try your call again.
type InternalServerError struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s InternalServerError) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s InternalServerError) GoString() string {
	return s.String()
}

func newErrorInternalServerError(v protocol.ResponseMetadata) error {
	return &InternalServerError{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *InternalServerError) Code() string {
	return "InternalServerError"
}

// Message returns the exception's message.
func (s *InternalServerError) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InternalServerError) OrigErr() error {
	return nil
}

func (s *InternalServerError) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *InternalServerError) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *InternalServerError) RequestID() string {
	return s.RespMetadata.RequestID
}

// An invalid job identifier was passed to GetDocumentAnalysis or to GetDocumentAnalysis.
type InvalidJobIdException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s InvalidJobIdException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s InvalidJobIdException) GoString() string {
	return s.String()
}

func newErrorInvalidJobIdException(v protocol.ResponseMetadata) error {
	return &InvalidJobIdException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *InvalidJobIdException) Code() string {
	return "InvalidJobIdException"
}

// Message returns the exception's message.
func (s *InvalidJobIdException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InvalidJobIdException) OrigErr() error {
	return nil
}

func (s *InvalidJobIdException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *InvalidJobIdException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *InvalidJobIdException) RequestID() string {
	return s.RespMetadata.RequestID
}

// Indicates you do not have decrypt permissions with the KMS key entered, or
// the KMS key was entered incorrectly.
type InvalidKMSKeyException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s InvalidKMSKeyException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s InvalidKMSKeyException) GoString() string {
	return s.String()
}

func newErrorInvalidKMSKeyException(v protocol.ResponseMetadata) error {
	return &InvalidKMSKeyException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *InvalidKMSKeyException) Code() string {
	return "InvalidKMSKeyException"
}

// Message returns the exception's message.
func (s *InvalidKMSKeyException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InvalidKMSKeyException) OrigErr() error {
	return nil
}

func (s *InvalidKMSKeyException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *InvalidKMSKeyException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *InvalidKMSKeyException) RequestID() string {
	return s.RespMetadata.RequestID
}

// 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.
type InvalidParameterException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s InvalidParameterException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s InvalidParameterException) GoString() string {
	return s.String()
}

func newErrorInvalidParameterException(v protocol.ResponseMetadata) error {
	return &InvalidParameterException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *InvalidParameterException) Code() string {
	return "InvalidParameterException"
}

// Message returns the exception's message.
func (s *InvalidParameterException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InvalidParameterException) OrigErr() error {
	return nil
}

func (s *InvalidParameterException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *InvalidParameterException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *InvalidParameterException) RequestID() string {
	return s.RespMetadata.RequestID
}

// 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)
type InvalidS3ObjectException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s InvalidS3ObjectException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s InvalidS3ObjectException) GoString() string {
	return s.String()
}

func newErrorInvalidS3ObjectException(v protocol.ResponseMetadata) error {
	return &InvalidS3ObjectException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *InvalidS3ObjectException) Code() string {
	return "InvalidS3ObjectException"
}

// Message returns the exception's message.
func (s *InvalidS3ObjectException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *InvalidS3ObjectException) OrigErr() error {
	return nil
}

func (s *InvalidS3ObjectException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *InvalidS3ObjectException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *InvalidS3ObjectException) RequestID() string {
	return s.RespMetadata.RequestID
}

// 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.
type LimitExceededException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s LimitExceededException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s LimitExceededException) GoString() string {
	return s.String()
}

func newErrorLimitExceededException(v protocol.ResponseMetadata) error {
	return &LimitExceededException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *LimitExceededException) Code() string {
	return "LimitExceededException"
}

// Message returns the exception's message.
func (s *LimitExceededException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *LimitExceededException) OrigErr() error {
	return nil
}

func (s *LimitExceededException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *LimitExceededException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *LimitExceededException) RequestID() string {
	return s.RespMetadata.RequestID
}

// A structure that holds information about the different lines found in a document's
// tables.
type LineItemFields struct {
	_ struct{} `type:"structure"`

	// ExpenseFields used to show information from detected lines on a table.
	LineItemExpenseFields []*ExpenseField `type:"list"`
}

// String returns the string representation
func (s LineItemFields) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s LineItemFields) GoString() string {
	return s.String()
}

// SetLineItemExpenseFields sets the LineItemExpenseFields field's value.
func (s *LineItemFields) SetLineItemExpenseFields(v []*ExpenseField) *LineItemFields {
	s.LineItemExpenseFields = v
	return s
}

// A grouping of tables which contain LineItems, with each table identified
// by the table's LineItemGroupIndex.
type LineItemGroup struct {
	_ struct{} `type:"structure"`

	// The number used to identify a specific table in a document. The first table
	// encountered will have a LineItemGroupIndex of 1, the second 2, etc.
	LineItemGroupIndex *int64 `type:"integer"`

	// The breakdown of information on a particular line of a table.
	LineItems []*LineItemFields `type:"list"`
}

// String returns the string representation
func (s LineItemGroup) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s LineItemGroup) GoString() string {
	return s.String()
}

// SetLineItemGroupIndex sets the LineItemGroupIndex field's value.
func (s *LineItemGroup) SetLineItemGroupIndex(v int64) *LineItemGroup {
	s.LineItemGroupIndex = &v
	return s
}

// SetLineItems sets the LineItems field's value.
func (s *LineItemGroup) SetLineItems(v []*LineItemFields) *LineItemGroup {
	s.LineItems = v
	return s
}

// 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 NotificationChannel struct {
	_ struct{} `type:"structure"`

	// The Amazon Resource Name (ARN) of an IAM role that gives Amazon Textract
	// publishing permissions to the Amazon SNS topic.
	//
	// RoleArn is a required field
	RoleArn *string `min:"20" type:"string" required:"true"`

	// The Amazon SNS topic that Amazon Textract posts the completion status to.
	//
	// SNSTopicArn is a required field
	SNSTopicArn *string `min:"20" type:"string" required:"true"`
}

// String returns the string representation
func (s NotificationChannel) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s NotificationChannel) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *NotificationChannel) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "NotificationChannel"}
	if s.RoleArn == nil {
		invalidParams.Add(request.NewErrParamRequired("RoleArn"))
	}
	if s.RoleArn != nil && len(*s.RoleArn) < 20 {
		invalidParams.Add(request.NewErrParamMinLen("RoleArn", 20))
	}
	if s.SNSTopicArn == nil {
		invalidParams.Add(request.NewErrParamRequired("SNSTopicArn"))
	}
	if s.SNSTopicArn != nil && len(*s.SNSTopicArn) < 20 {
		invalidParams.Add(request.NewErrParamMinLen("SNSTopicArn", 20))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetRoleArn sets the RoleArn field's value.
func (s *NotificationChannel) SetRoleArn(v string) *NotificationChannel {
	s.RoleArn = &v
	return s
}

// SetSNSTopicArn sets the SNSTopicArn field's value.
func (s *NotificationChannel) SetSNSTopicArn(v string) *NotificationChannel {
	s.SNSTopicArn = &v
	return s
}

// 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.
//
// OutputConfig is an optional parameter which lets you adjust where your output
// will be placed. By default, Amazon Textract will store the results internally
// and can only be accessed by the Get API operations. With OutputConfig enabled,
// you can set the name of the bucket the output will be sent to and the file
// prefix of the results where you can download your results. Additionally,
// you can set the KMSKeyID parameter to a customer master key (CMK) to encrypt
// your output. Without this parameter set Amazon Textract will encrypt server-side
// using the AWS managed CMK for Amazon S3.
//
// Decryption of Customer Content is necessary for processing of the documents
// by Amazon Textract. If your account is opted out under an AI services opt
// out policy then all unencrypted Customer Content is immediately and permanently
// deleted after the Customer Content has been processed by the service. No
// copy of of the output is retained by Amazon Textract. For information about
// how to opt out, see Managing AI services opt-out policy. (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html)
//
// For more information on data privacy, see the Data Privacy FAQ (https://aws.amazon.com/compliance/data-privacy-faq/).
type OutputConfig struct {
	_ struct{} `type:"structure"`

	// The name of the bucket your output will go to.
	//
	// S3Bucket is a required field
	S3Bucket *string `min:"3" type:"string" required:"true"`

	// The prefix of the object key that the output will be saved to. When not enabled,
	// the prefix will be “textract_output".
	S3Prefix *string `min:"1" type:"string"`
}

// String returns the string representation
func (s OutputConfig) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s OutputConfig) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *OutputConfig) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "OutputConfig"}
	if s.S3Bucket == nil {
		invalidParams.Add(request.NewErrParamRequired("S3Bucket"))
	}
	if s.S3Bucket != nil && len(*s.S3Bucket) < 3 {
		invalidParams.Add(request.NewErrParamMinLen("S3Bucket", 3))
	}
	if s.S3Prefix != nil && len(*s.S3Prefix) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("S3Prefix", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetS3Bucket sets the S3Bucket field's value.
func (s *OutputConfig) SetS3Bucket(v string) *OutputConfig {
	s.S3Bucket = &v
	return s
}

// SetS3Prefix sets the S3Prefix field's value.
func (s *OutputConfig) SetS3Prefix(v string) *OutputConfig {
	s.S3Prefix = &v
	return s
}

// 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 Point struct {
	_ struct{} `type:"structure"`

	// The value of the X coordinate for a point on a Polygon.
	X *float64 `type:"float"`

	// The value of the Y coordinate for a point on a Polygon.
	Y *float64 `type:"float"`
}

// String returns the string representation
func (s Point) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Point) GoString() string {
	return s.String()
}

// SetX sets the X field's value.
func (s *Point) SetX(v float64) *Point {
	s.X = &v
	return s
}

// SetY sets the Y field's value.
func (s *Point) SetY(v float64) *Point {
	s.Y = &v
	return s
}

// The number of requests exceeded your throughput limit. If you want to increase
// this limit, contact Amazon Textract.
type ProvisionedThroughputExceededException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s ProvisionedThroughputExceededException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ProvisionedThroughputExceededException) GoString() string {
	return s.String()
}

func newErrorProvisionedThroughputExceededException(v protocol.ResponseMetadata) error {
	return &ProvisionedThroughputExceededException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *ProvisionedThroughputExceededException) Code() string {
	return "ProvisionedThroughputExceededException"
}

// Message returns the exception's message.
func (s *ProvisionedThroughputExceededException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ProvisionedThroughputExceededException) OrigErr() error {
	return nil
}

func (s *ProvisionedThroughputExceededException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *ProvisionedThroughputExceededException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *ProvisionedThroughputExceededException) RequestID() string {
	return s.RespMetadata.RequestID
}

// 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 Relationship struct {
	_ struct{} `type:"structure"`

	// An array of IDs for related blocks. You can get the type of the relationship
	// from the Type element.
	Ids []*string `type:"list"`

	// 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 *string `type:"string" enum:"RelationshipType"`
}

// String returns the string representation
func (s Relationship) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Relationship) GoString() string {
	return s.String()
}

// SetIds sets the Ids field's value.
func (s *Relationship) SetIds(v []*string) *Relationship {
	s.Ids = v
	return s
}

// SetType sets the Type field's value.
func (s *Relationship) SetType(v string) *Relationship {
	s.Type = &v
	return s
}

// 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 S3Object struct {
	_ struct{} `type:"structure"`

	// The name of the S3 bucket. Note that the # character is not valid in the
	// file name.
	Bucket *string `min:"3" type:"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 `min:"1" type:"string"`

	// If the bucket has versioning enabled, you can specify the object version.
	Version *string `min:"1" type:"string"`
}

// String returns the string representation
func (s S3Object) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s S3Object) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *S3Object) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "S3Object"}
	if s.Bucket != nil && len(*s.Bucket) < 3 {
		invalidParams.Add(request.NewErrParamMinLen("Bucket", 3))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Name", 1))
	}
	if s.Version != nil && len(*s.Version) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("Version", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetBucket sets the Bucket field's value.
func (s *S3Object) SetBucket(v string) *S3Object {
	s.Bucket = &v
	return s
}

// SetName sets the Name field's value.
func (s *S3Object) SetName(v string) *S3Object {
	s.Name = &v
	return s
}

// SetVersion sets the Version field's value.
func (s *S3Object) SetVersion(v string) *S3Object {
	s.Version = &v
	return s
}

type StartDocumentAnalysisInput struct {
	_ struct{} `type:"structure"`

	// The idempotent token that you use to identify the start request. If you use
	// the same token with multiple StartDocumentAnalysis requests, the same JobId
	// is returned. Use ClientRequestToken to prevent the same job from being accidentally
	// started more than once. For more information, see Calling Amazon Textract
	// Asynchronous Operations (https://docs.aws.amazon.com/textract/latest/dg/api-async.html).
	ClientRequestToken *string `min:"1" type:"string"`

	// The location of the document to be processed.
	//
	// DocumentLocation is a required field
	DocumentLocation *DocumentLocation `type:"structure" required:"true"`

	// A list of the types of analysis to perform. Add TABLES to the list to return
	// information about the tables that are detected in the input document. Add
	// FORMS to return detected form data. To perform both types of analysis, add
	// TABLES and FORMS to FeatureTypes. All lines and words detected in the document
	// are included in the response (including text that isn't related to the value
	// of FeatureTypes).
	//
	// FeatureTypes is a required field
	FeatureTypes []*string `type:"list" required:"true"`

	// An identifier that you specify that's included in the completion notification
	// published to the Amazon SNS topic. For example, you can use JobTag to identify
	// the type of document that the completion notification corresponds to (such
	// as a tax form or a receipt).
	JobTag *string `min:"1" type:"string"`

	// The KMS key used to encrypt the inference results. This can be in either
	// Key ID or Key Alias format. When a KMS key is provided, the KMS key will
	// be used for server-side encryption of the objects in the customer bucket.
	// When this parameter is not enabled, the result will be encrypted server side,using
	// SSE-S3.
	KMSKeyId *string `min:"1" type:"string"`

	// The Amazon SNS topic ARN that you want Amazon Textract to publish the completion
	// status of the operation to.
	NotificationChannel *NotificationChannel `type:"structure"`

	// Sets if the output will go to a customer defined bucket. By default, Amazon
	// Textract will save the results internally to be accessed by the GetDocumentAnalysis
	// operation.
	OutputConfig *OutputConfig `type:"structure"`
}

// String returns the string representation
func (s StartDocumentAnalysisInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StartDocumentAnalysisInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *StartDocumentAnalysisInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "StartDocumentAnalysisInput"}
	if s.ClientRequestToken != nil && len(*s.ClientRequestToken) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientRequestToken", 1))
	}
	if s.DocumentLocation == nil {
		invalidParams.Add(request.NewErrParamRequired("DocumentLocation"))
	}
	if s.FeatureTypes == nil {
		invalidParams.Add(request.NewErrParamRequired("FeatureTypes"))
	}
	if s.JobTag != nil && len(*s.JobTag) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("JobTag", 1))
	}
	if s.KMSKeyId != nil && len(*s.KMSKeyId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("KMSKeyId", 1))
	}
	if s.DocumentLocation != nil {
		if err := s.DocumentLocation.Validate(); err != nil {
			invalidParams.AddNested("DocumentLocation", err.(request.ErrInvalidParams))
		}
	}
	if s.NotificationChannel != nil {
		if err := s.NotificationChannel.Validate(); err != nil {
			invalidParams.AddNested("NotificationChannel", err.(request.ErrInvalidParams))
		}
	}
	if s.OutputConfig != nil {
		if err := s.OutputConfig.Validate(); err != nil {
			invalidParams.AddNested("OutputConfig", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetClientRequestToken sets the ClientRequestToken field's value.
func (s *StartDocumentAnalysisInput) SetClientRequestToken(v string) *StartDocumentAnalysisInput {
	s.ClientRequestToken = &v
	return s
}

// SetDocumentLocation sets the DocumentLocation field's value.
func (s *StartDocumentAnalysisInput) SetDocumentLocation(v *DocumentLocation) *StartDocumentAnalysisInput {
	s.DocumentLocation = v
	return s
}

// SetFeatureTypes sets the FeatureTypes field's value.
func (s *StartDocumentAnalysisInput) SetFeatureTypes(v []*string) *StartDocumentAnalysisInput {
	s.FeatureTypes = v
	return s
}

// SetJobTag sets the JobTag field's value.
func (s *StartDocumentAnalysisInput) SetJobTag(v string) *StartDocumentAnalysisInput {
	s.JobTag = &v
	return s
}

// SetKMSKeyId sets the KMSKeyId field's value.
func (s *StartDocumentAnalysisInput) SetKMSKeyId(v string) *StartDocumentAnalysisInput {
	s.KMSKeyId = &v
	return s
}

// SetNotificationChannel sets the NotificationChannel field's value.
func (s *StartDocumentAnalysisInput) SetNotificationChannel(v *NotificationChannel) *StartDocumentAnalysisInput {
	s.NotificationChannel = v
	return s
}

// SetOutputConfig sets the OutputConfig field's value.
func (s *StartDocumentAnalysisInput) SetOutputConfig(v *OutputConfig) *StartDocumentAnalysisInput {
	s.OutputConfig = v
	return s
}

type StartDocumentAnalysisOutput struct {
	_ struct{} `type:"structure"`

	// The identifier for the document text detection job. Use JobId to identify
	// the job in a subsequent call to GetDocumentAnalysis. A JobId value is only
	// valid for 7 days.
	JobId *string `min:"1" type:"string"`
}

// String returns the string representation
func (s StartDocumentAnalysisOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StartDocumentAnalysisOutput) GoString() string {
	return s.String()
}

// SetJobId sets the JobId field's value.
func (s *StartDocumentAnalysisOutput) SetJobId(v string) *StartDocumentAnalysisOutput {
	s.JobId = &v
	return s
}

type StartDocumentTextDetectionInput struct {
	_ struct{} `type:"structure"`

	// The idempotent token that's used to identify the start request. If you use
	// the same token with multiple StartDocumentTextDetection requests, the same
	// JobId is returned. Use ClientRequestToken to prevent the same job from being
	// accidentally started more than once. For more information, see Calling Amazon
	// Textract Asynchronous Operations (https://docs.aws.amazon.com/textract/latest/dg/api-async.html).
	ClientRequestToken *string `min:"1" type:"string"`

	// The location of the document to be processed.
	//
	// DocumentLocation is a required field
	DocumentLocation *DocumentLocation `type:"structure" required:"true"`

	// An identifier that you specify that's included in the completion notification
	// published to the Amazon SNS topic. For example, you can use JobTag to identify
	// the type of document that the completion notification corresponds to (such
	// as a tax form or a receipt).
	JobTag *string `min:"1" type:"string"`

	// The KMS key used to encrypt the inference results. This can be in either
	// Key ID or Key Alias format. When a KMS key is provided, the KMS key will
	// be used for server-side encryption of the objects in the customer bucket.
	// When this parameter is not enabled, the result will be encrypted server side,using
	// SSE-S3.
	KMSKeyId *string `min:"1" type:"string"`

	// The Amazon SNS topic ARN that you want Amazon Textract to publish the completion
	// status of the operation to.
	NotificationChannel *NotificationChannel `type:"structure"`

	// Sets if the output will go to a customer defined bucket. By default Amazon
	// Textract will save the results internally to be accessed with the GetDocumentTextDetection
	// operation.
	OutputConfig *OutputConfig `type:"structure"`
}

// String returns the string representation
func (s StartDocumentTextDetectionInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StartDocumentTextDetectionInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *StartDocumentTextDetectionInput) Validate() error {
	invalidParams := request.ErrInvalidParams{Context: "StartDocumentTextDetectionInput"}
	if s.ClientRequestToken != nil && len(*s.ClientRequestToken) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("ClientRequestToken", 1))
	}
	if s.DocumentLocation == nil {
		invalidParams.Add(request.NewErrParamRequired("DocumentLocation"))
	}
	if s.JobTag != nil && len(*s.JobTag) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("JobTag", 1))
	}
	if s.KMSKeyId != nil && len(*s.KMSKeyId) < 1 {
		invalidParams.Add(request.NewErrParamMinLen("KMSKeyId", 1))
	}
	if s.DocumentLocation != nil {
		if err := s.DocumentLocation.Validate(); err != nil {
			invalidParams.AddNested("DocumentLocation", err.(request.ErrInvalidParams))
		}
	}
	if s.NotificationChannel != nil {
		if err := s.NotificationChannel.Validate(); err != nil {
			invalidParams.AddNested("NotificationChannel", err.(request.ErrInvalidParams))
		}
	}
	if s.OutputConfig != nil {
		if err := s.OutputConfig.Validate(); err != nil {
			invalidParams.AddNested("OutputConfig", err.(request.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetClientRequestToken sets the ClientRequestToken field's value.
func (s *StartDocumentTextDetectionInput) SetClientRequestToken(v string) *StartDocumentTextDetectionInput {
	s.ClientRequestToken = &v
	return s
}

// SetDocumentLocation sets the DocumentLocation field's value.
func (s *StartDocumentTextDetectionInput) SetDocumentLocation(v *DocumentLocation) *StartDocumentTextDetectionInput {
	s.DocumentLocation = v
	return s
}

// SetJobTag sets the JobTag field's value.
func (s *StartDocumentTextDetectionInput) SetJobTag(v string) *StartDocumentTextDetectionInput {
	s.JobTag = &v
	return s
}

// SetKMSKeyId sets the KMSKeyId field's value.
func (s *StartDocumentTextDetectionInput) SetKMSKeyId(v string) *StartDocumentTextDetectionInput {
	s.KMSKeyId = &v
	return s
}

// SetNotificationChannel sets the NotificationChannel field's value.
func (s *StartDocumentTextDetectionInput) SetNotificationChannel(v *NotificationChannel) *StartDocumentTextDetectionInput {
	s.NotificationChannel = v
	return s
}

// SetOutputConfig sets the OutputConfig field's value.
func (s *StartDocumentTextDetectionInput) SetOutputConfig(v *OutputConfig) *StartDocumentTextDetectionInput {
	s.OutputConfig = v
	return s
}

type StartDocumentTextDetectionOutput struct {
	_ struct{} `type:"structure"`

	// The identifier of the text detection job for the document. Use JobId to identify
	// the job in a subsequent call to GetDocumentTextDetection. A JobId value is
	// only valid for 7 days.
	JobId *string `min:"1" type:"string"`
}

// String returns the string representation
func (s StartDocumentTextDetectionOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s StartDocumentTextDetectionOutput) GoString() string {
	return s.String()
}

// SetJobId sets the JobId field's value.
func (s *StartDocumentTextDetectionOutput) SetJobId(v string) *StartDocumentTextDetectionOutput {
	s.JobId = &v
	return s
}

// Amazon Textract is temporarily unable to process the request. Try your call
// again.
type ThrottlingException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s ThrottlingException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ThrottlingException) GoString() string {
	return s.String()
}

func newErrorThrottlingException(v protocol.ResponseMetadata) error {
	return &ThrottlingException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *ThrottlingException) Code() string {
	return "ThrottlingException"
}

// Message returns the exception's message.
func (s *ThrottlingException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *ThrottlingException) OrigErr() error {
	return nil
}

func (s *ThrottlingException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *ThrottlingException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *ThrottlingException) RequestID() string {
	return s.RespMetadata.RequestID
}

// 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.
type UnsupportedDocumentException struct {
	_            struct{}                  `type:"structure"`
	RespMetadata protocol.ResponseMetadata `json:"-" xml:"-"`

	Message_ *string `locationName:"message" type:"string"`
}

// String returns the string representation
func (s UnsupportedDocumentException) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UnsupportedDocumentException) GoString() string {
	return s.String()
}

func newErrorUnsupportedDocumentException(v protocol.ResponseMetadata) error {
	return &UnsupportedDocumentException{
		RespMetadata: v,
	}
}

// Code returns the exception type name.
func (s *UnsupportedDocumentException) Code() string {
	return "UnsupportedDocumentException"
}

// Message returns the exception's message.
func (s *UnsupportedDocumentException) Message() string {
	if s.Message_ != nil {
		return *s.Message_
	}
	return ""
}

// OrigErr always returns nil, satisfies awserr.Error interface.
func (s *UnsupportedDocumentException) OrigErr() error {
	return nil
}

func (s *UnsupportedDocumentException) Error() string {
	return fmt.Sprintf("%s: %s", s.Code(), s.Message())
}

// Status code returns the HTTP status code for the request's response error.
func (s *UnsupportedDocumentException) StatusCode() int {
	return s.RespMetadata.StatusCode
}

// RequestID returns the service's response RequestID for request.
func (s *UnsupportedDocumentException) RequestID() string {
	return s.RespMetadata.RequestID
}

// A warning about an issue that occurred during asynchronous text analysis
// (StartDocumentAnalysis) or asynchronous document text detection (StartDocumentTextDetection).
type Warning struct {
	_ struct{} `type:"structure"`

	// The error code for the warning.
	ErrorCode *string `type:"string"`

	// A list of the pages that the warning applies to.
	Pages []*int64 `type:"list"`
}

// String returns the string representation
func (s Warning) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Warning) GoString() string {
	return s.String()
}

// SetErrorCode sets the ErrorCode field's value.
func (s *Warning) SetErrorCode(v string) *Warning {
	s.ErrorCode = &v
	return s
}

// SetPages sets the Pages field's value.
func (s *Warning) SetPages(v []*int64) *Warning {
	s.Pages = v
	return s
}

const (
	// BlockTypeKeyValueSet is a BlockType enum value
	BlockTypeKeyValueSet = "KEY_VALUE_SET"

	// BlockTypePage is a BlockType enum value
	BlockTypePage = "PAGE"

	// BlockTypeLine is a BlockType enum value
	BlockTypeLine = "LINE"

	// BlockTypeWord is a BlockType enum value
	BlockTypeWord = "WORD"

	// BlockTypeTable is a BlockType enum value
	BlockTypeTable = "TABLE"

	// BlockTypeCell is a BlockType enum value
	BlockTypeCell = "CELL"

	// BlockTypeSelectionElement is a BlockType enum value
	BlockTypeSelectionElement = "SELECTION_ELEMENT"
)

// BlockType_Values returns all elements of the BlockType enum
func BlockType_Values() []string {
	return []string{
		BlockTypeKeyValueSet,
		BlockTypePage,
		BlockTypeLine,
		BlockTypeWord,
		BlockTypeTable,
		BlockTypeCell,
		BlockTypeSelectionElement,
	}
}

const (
	// ContentClassifierFreeOfPersonallyIdentifiableInformation is a ContentClassifier enum value
	ContentClassifierFreeOfPersonallyIdentifiableInformation = "FreeOfPersonallyIdentifiableInformation"

	// ContentClassifierFreeOfAdultContent is a ContentClassifier enum value
	ContentClassifierFreeOfAdultContent = "FreeOfAdultContent"
)

// ContentClassifier_Values returns all elements of the ContentClassifier enum
func ContentClassifier_Values() []string {
	return []string{
		ContentClassifierFreeOfPersonallyIdentifiableInformation,
		ContentClassifierFreeOfAdultContent,
	}
}

const (
	// EntityTypeKey is a EntityType enum value
	EntityTypeKey = "KEY"

	// EntityTypeValue is a EntityType enum value
	EntityTypeValue = "VALUE"
)

// EntityType_Values returns all elements of the EntityType enum
func EntityType_Values() []string {
	return []string{
		EntityTypeKey,
		EntityTypeValue,
	}
}

const (
	// FeatureTypeTables is a FeatureType enum value
	FeatureTypeTables = "TABLES"

	// FeatureTypeForms is a FeatureType enum value
	FeatureTypeForms = "FORMS"
)

// FeatureType_Values returns all elements of the FeatureType enum
func FeatureType_Values() []string {
	return []string{
		FeatureTypeTables,
		FeatureTypeForms,
	}
}

const (
	// JobStatusInProgress is a JobStatus enum value
	JobStatusInProgress = "IN_PROGRESS"

	// JobStatusSucceeded is a JobStatus enum value
	JobStatusSucceeded = "SUCCEEDED"

	// JobStatusFailed is a JobStatus enum value
	JobStatusFailed = "FAILED"

	// JobStatusPartialSuccess is a JobStatus enum value
	JobStatusPartialSuccess = "PARTIAL_SUCCESS"
)

// JobStatus_Values returns all elements of the JobStatus enum
func JobStatus_Values() []string {
	return []string{
		JobStatusInProgress,
		JobStatusSucceeded,
		JobStatusFailed,
		JobStatusPartialSuccess,
	}
}

const (
	// RelationshipTypeValue is a RelationshipType enum value
	RelationshipTypeValue = "VALUE"

	// RelationshipTypeChild is a RelationshipType enum value
	RelationshipTypeChild = "CHILD"

	// RelationshipTypeComplexFeatures is a RelationshipType enum value
	RelationshipTypeComplexFeatures = "COMPLEX_FEATURES"
)

// RelationshipType_Values returns all elements of the RelationshipType enum
func RelationshipType_Values() []string {
	return []string{
		RelationshipTypeValue,
		RelationshipTypeChild,
		RelationshipTypeComplexFeatures,
	}
}

const (
	// SelectionStatusSelected is a SelectionStatus enum value
	SelectionStatusSelected = "SELECTED"

	// SelectionStatusNotSelected is a SelectionStatus enum value
	SelectionStatusNotSelected = "NOT_SELECTED"
)

// SelectionStatus_Values returns all elements of the SelectionStatus enum
func SelectionStatus_Values() []string {
	return []string{
		SelectionStatusSelected,
		SelectionStatusNotSelected,
	}
}

const (
	// TextTypeHandwriting is a TextType enum value
	TextTypeHandwriting = "HANDWRITING"

	// TextTypePrinted is a TextType enum value
	TextTypePrinted = "PRINTED"
)

// TextType_Values returns all elements of the TextType enum
func TextType_Values() []string {
	return []string{
		TextTypeHandwriting,
		TextTypePrinted,
	}
}