com.amazonaws.services.textract.AmazonTextractAsync Maven / Gradle / Ivy

/*
 * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
 * the License. A copy of the License is located at
 * 
 * http://aws.amazon.com/apache2.0
 * 
 * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
 * and limitations under the License.
 */
package com.amazonaws.services.textract;

import javax.annotation.Generated;

import com.amazonaws.services.textract.model.*;

/**
 * Interface for accessing Amazon Textract asynchronously. Each asynchronous method will return a Java Future object
 * representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
 * notification when an asynchronous operation completes.
 * 
 * Note: Do not directly implement this interface, new methods are added to it regularly. Extend from
 * {@link com.amazonaws.services.textract.AbstractAmazonTextractAsync} instead.
 * 
 * 
 * 

 * Amazon Textract detects and analyzes text in documents and converts it into machine-readable text. This is the API
 * reference documentation for Amazon Textract.
 * 
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public interface AmazonTextractAsync extends AmazonTextract {

    /**
     * 
     * 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).
     * 
     * 
     * 
     * 
     * Signatures. A SIGNATURE Block object contains the location information of a signature in a document.
     * If used in conjunction with forms or tables, a signature can be given a Key-Value pairing or be detected in the
     * cell of a table.
     * 
     * 
     * 
     * 
     * Query. A QUERY Block object contains the query text, alias and link to the associated Query results block object.
     * 
     * 
     * 
     * 
     * Query Result. A QUERY_RESULT Block object contains the answer to the query and an ID that connects it to the
     * query asked. This Block also contains a confidence score.
     * 
     * 
     * 
     * 
     * 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.
     * 
     * 
     * @param analyzeDocumentRequest
     * @return A Java Future containing the result of the AnalyzeDocument operation returned by the service.
     * @sample AmazonTextractAsync.AnalyzeDocument
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future analyzeDocumentAsync(AnalyzeDocumentRequest analyzeDocumentRequest);

    /**
     * 
     * 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).
     * 
     * 
     * 
     * 
     * Signatures. A SIGNATURE Block object contains the location information of a signature in a document.
     * If used in conjunction with forms or tables, a signature can be given a Key-Value pairing or be detected in the
     * cell of a table.
     * 
     * 
     * 
     * 
     * Query. A QUERY Block object contains the query text, alias and link to the associated Query results block object.
     * 
     * 
     * 
     * 
     * Query Result. A QUERY_RESULT Block object contains the answer to the query and an ID that connects it to the
     * query asked. This Block also contains a confidence score.
     * 
     * 
     * 
     * 
     * 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.
     * 
     * 
     * @param analyzeDocumentRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the AnalyzeDocument operation returned by the service.
     * @sample AmazonTextractAsyncHandler.AnalyzeDocument
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future analyzeDocumentAsync(AnalyzeDocumentRequest analyzeDocumentRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * AnalyzeExpense synchronously 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.
     * 
     * 
     * 
     * 
     * @param analyzeExpenseRequest
     * @return A Java Future containing the result of the AnalyzeExpense operation returned by the service.
     * @sample AmazonTextractAsync.AnalyzeExpense
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future analyzeExpenseAsync(AnalyzeExpenseRequest analyzeExpenseRequest);

    /**
     * 
     * AnalyzeExpense synchronously 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.
     * 
     * 
     * 
     * 
     * @param analyzeExpenseRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the AnalyzeExpense operation returned by the service.
     * @sample AmazonTextractAsyncHandler.AnalyzeExpense
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future analyzeExpenseAsync(AnalyzeExpenseRequest analyzeExpenseRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Analyzes identity documents for relevant information. This information is extracted and returned as
     * IdentityDocumentFields, which records both the normalized field and value of the extracted text.
     * Unlike other Amazon Textract operations, AnalyzeID doesn't return any Geometry data.
     * 
     * 
     * @param analyzeIDRequest
     * @return A Java Future containing the result of the AnalyzeID operation returned by the service.
     * @sample AmazonTextractAsync.AnalyzeID
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future analyzeIDAsync(AnalyzeIDRequest analyzeIDRequest);

    /**
     * 
     * Analyzes identity documents for relevant information. This information is extracted and returned as
     * IdentityDocumentFields, which records both the normalized field and value of the extracted text.
     * Unlike other Amazon Textract operations, AnalyzeID doesn't return any Geometry data.
     * 
     * 
     * @param analyzeIDRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the AnalyzeID operation returned by the service.
     * @sample AmazonTextractAsyncHandler.AnalyzeID
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future analyzeIDAsync(AnalyzeIDRequest analyzeIDRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Creates an adapter, which can be fine-tuned for enhanced performance on user provided documents. Takes an
     * AdapterName and FeatureType. Currently the only supported feature type is QUERIES. You can also
     * provide a Description, Tags, and a ClientRequestToken. You can choose whether or not the adapter should be
     * AutoUpdated with the AutoUpdate argument. By default, AutoUpdate is set to DISABLED.
     * 
     * 
     * @param createAdapterRequest
     * @return A Java Future containing the result of the CreateAdapter operation returned by the service.
     * @sample AmazonTextractAsync.CreateAdapter
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future createAdapterAsync(CreateAdapterRequest createAdapterRequest);

    /**
     * 
     * Creates an adapter, which can be fine-tuned for enhanced performance on user provided documents. Takes an
     * AdapterName and FeatureType. Currently the only supported feature type is QUERIES. You can also
     * provide a Description, Tags, and a ClientRequestToken. You can choose whether or not the adapter should be
     * AutoUpdated with the AutoUpdate argument. By default, AutoUpdate is set to DISABLED.
     * 
     * 
     * @param createAdapterRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateAdapter operation returned by the service.
     * @sample AmazonTextractAsyncHandler.CreateAdapter
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future createAdapterAsync(CreateAdapterRequest createAdapterRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Creates a new version of an adapter. Operates on a provided AdapterId and a specified dataset provided via the
     * DatasetConfig argument. Requires that you specify an Amazon S3 bucket with the OutputConfig argument. You can
     * provide an optional KMSKeyId, an optional ClientRequestToken, and optional tags.
     * 
     * 
     * @param createAdapterVersionRequest
     * @return A Java Future containing the result of the CreateAdapterVersion operation returned by the service.
     * @sample AmazonTextractAsync.CreateAdapterVersion
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future createAdapterVersionAsync(CreateAdapterVersionRequest createAdapterVersionRequest);

    /**
     * 
     * Creates a new version of an adapter. Operates on a provided AdapterId and a specified dataset provided via the
     * DatasetConfig argument. Requires that you specify an Amazon S3 bucket with the OutputConfig argument. You can
     * provide an optional KMSKeyId, an optional ClientRequestToken, and optional tags.
     * 
     * 
     * @param createAdapterVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateAdapterVersion operation returned by the service.
     * @sample AmazonTextractAsyncHandler.CreateAdapterVersion
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future createAdapterVersionAsync(CreateAdapterVersionRequest createAdapterVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Deletes an Amazon Textract adapter. Takes an AdapterId and deletes the adapter specified by the ID.
     * 
     * 
     * @param deleteAdapterRequest
     * @return A Java Future containing the result of the DeleteAdapter operation returned by the service.
     * @sample AmazonTextractAsync.DeleteAdapter
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future deleteAdapterAsync(DeleteAdapterRequest deleteAdapterRequest);

    /**
     * 
     * Deletes an Amazon Textract adapter. Takes an AdapterId and deletes the adapter specified by the ID.
     * 
     * 
     * @param deleteAdapterRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteAdapter operation returned by the service.
     * @sample AmazonTextractAsyncHandler.DeleteAdapter
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future deleteAdapterAsync(DeleteAdapterRequest deleteAdapterRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Deletes an Amazon Textract adapter version. Requires that you specify both an AdapterId and a AdapterVersion.
     * Deletes the adapter version specified by the AdapterId and the AdapterVersion.
     * 
     * 
     * @param deleteAdapterVersionRequest
     * @return A Java Future containing the result of the DeleteAdapterVersion operation returned by the service.
     * @sample AmazonTextractAsync.DeleteAdapterVersion
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future deleteAdapterVersionAsync(DeleteAdapterVersionRequest deleteAdapterVersionRequest);

    /**
     * 
     * Deletes an Amazon Textract adapter version. Requires that you specify both an AdapterId and a AdapterVersion.
     * Deletes the adapter version specified by the AdapterId and the AdapterVersion.
     * 
     * 
     * @param deleteAdapterVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteAdapterVersion operation returned by the service.
     * @sample AmazonTextractAsyncHandler.DeleteAdapterVersion
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future deleteAdapterVersionAsync(DeleteAdapterVersionRequest deleteAdapterVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * 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 in one of the following image formats: JPEG, PNG, PDF, or TIFF.
     * 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.
     * 
     * 
     * @param detectDocumentTextRequest
     * @return A Java Future containing the result of the DetectDocumentText operation returned by the service.
     * @sample AmazonTextractAsync.DetectDocumentText
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future detectDocumentTextAsync(DetectDocumentTextRequest detectDocumentTextRequest);

    /**
     * 
     * 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 in one of the following image formats: JPEG, PNG, PDF, or TIFF.
     * 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.
     * 
     * 
     * @param detectDocumentTextRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DetectDocumentText operation returned by the service.
     * @sample AmazonTextractAsyncHandler.DetectDocumentText
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future detectDocumentTextAsync(DetectDocumentTextRequest detectDocumentTextRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Gets configuration information for an adapter specified by an AdapterId, returning information on AdapterName,
     * Description, CreationTime, AutoUpdate status, and FeatureTypes.
     * 
     * 
     * @param getAdapterRequest
     * @return A Java Future containing the result of the GetAdapter operation returned by the service.
     * @sample AmazonTextractAsync.GetAdapter
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future getAdapterAsync(GetAdapterRequest getAdapterRequest);

    /**
     * 
     * Gets configuration information for an adapter specified by an AdapterId, returning information on AdapterName,
     * Description, CreationTime, AutoUpdate status, and FeatureTypes.
     * 
     * 
     * @param getAdapterRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetAdapter operation returned by the service.
     * @sample AmazonTextractAsyncHandler.GetAdapter
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future getAdapterAsync(GetAdapterRequest getAdapterRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Gets configuration information for the specified adapter version, including: AdapterId, AdapterVersion,
     * FeatureTypes, Status, StatusMessage, DatasetConfig, KMSKeyId, OutputConfig, Tags and EvaluationMetrics.
     * 
     * 
     * @param getAdapterVersionRequest
     * @return A Java Future containing the result of the GetAdapterVersion operation returned by the service.
     * @sample AmazonTextractAsync.GetAdapterVersion
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future getAdapterVersionAsync(GetAdapterVersionRequest getAdapterVersionRequest);

    /**
     * 
     * Gets configuration information for the specified adapter version, including: AdapterId, AdapterVersion,
     * FeatureTypes, Status, StatusMessage, DatasetConfig, KMSKeyId, OutputConfig, Tags and EvaluationMetrics.
     * 
     * 
     * @param getAdapterVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetAdapterVersion operation returned by the service.
     * @sample AmazonTextractAsyncHandler.GetAdapterVersion
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future getAdapterVersionAsync(GetAdapterVersionRequest getAdapterVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * 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).
     * 
     * 
     * 
     * 
     * Query. A QUERY Block object contains the query text, alias and link to the associated Query results block object.
     * 
     * 
     * 
     * 
     * Query Results. A QUERY_RESULT Block object contains the answer to the query and an ID that connects it to the
     * query asked. This Block also contains a confidence score.
     * 
     * 
     * 
     * 
     * 
     * While processing a document with queries, look out for INVALID_REQUEST_PARAMETERS output. This
     * indicates that either the per page query limit has been exceeded or that the operation is trying to query a page
     * in the document which doesn’t exist.
     * 
     * 
     * 
     * 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.
     * 
     * 
     * @param getDocumentAnalysisRequest
     * @return A Java Future containing the result of the GetDocumentAnalysis operation returned by the service.
     * @sample AmazonTextractAsync.GetDocumentAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getDocumentAnalysisAsync(GetDocumentAnalysisRequest getDocumentAnalysisRequest);

    /**
     * 
     * 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).
     * 
     * 
     * 
     * 
     * Query. A QUERY Block object contains the query text, alias and link to the associated Query results block object.
     * 
     * 
     * 
     * 
     * Query Results. A QUERY_RESULT Block object contains the answer to the query and an ID that connects it to the
     * query asked. This Block also contains a confidence score.
     * 
     * 
     * 
     * 
     * 
     * While processing a document with queries, look out for INVALID_REQUEST_PARAMETERS output. This
     * indicates that either the per page query limit has been exceeded or that the operation is trying to query a page
     * in the document which doesn’t exist.
     * 
     * 
     * 
     * 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.
     * 
     * 
     * @param getDocumentAnalysisRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetDocumentAnalysis operation returned by the service.
     * @sample AmazonTextractAsyncHandler.GetDocumentAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getDocumentAnalysisAsync(GetDocumentAnalysisRequest getDocumentAnalysisRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * 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.
     * 
     * 
     * @param getDocumentTextDetectionRequest
     * @return A Java Future containing the result of the GetDocumentTextDetection operation returned by the service.
     * @sample AmazonTextractAsync.GetDocumentTextDetection
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getDocumentTextDetectionAsync(GetDocumentTextDetectionRequest getDocumentTextDetectionRequest);

    /**
     * 
     * 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.
     * 
     * 
     * @param getDocumentTextDetectionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetDocumentTextDetection operation returned by the service.
     * @sample AmazonTextractAsyncHandler.GetDocumentTextDetection
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getDocumentTextDetectionAsync(GetDocumentTextDetectionRequest getDocumentTextDetectionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Gets the results for an Amazon Textract asynchronous operation that analyzes invoices and receipts. Amazon
     * Textract finds contact information, items purchased, and vendor name, from input invoices and receipts.
     * 
     * 
     * You start asynchronous invoice/receipt analysis by calling StartExpenseAnalysis, which returns a job
     * identifier (JobId). Upon completion of the invoice/receipt analysis, Amazon Textract publishes the
     * completion status to the Amazon Simple Notification Service (Amazon SNS) topic. This topic must be registered in
     * the initial call to StartExpenseAnalysis. To get the results of the invoice/receipt analysis
     * operation, first ensure that the status value published to the Amazon SNS topic is SUCCEEDED. If so,
     * call GetExpenseAnalysis, and pass the job identifier (JobId) from the initial call to
     * StartExpenseAnalysis.
     * 
     * 
     * 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
     * GetExpenseAnalysis, and populate the NextToken request parameter with the token value
     * that's returned from the previous call to GetExpenseAnalysis.
     * 
     * 
     * For more information, see Analyzing Invoices and Receipts.
     * 
     * 
     * @param getExpenseAnalysisRequest
     * @return A Java Future containing the result of the GetExpenseAnalysis operation returned by the service.
     * @sample AmazonTextractAsync.GetExpenseAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getExpenseAnalysisAsync(GetExpenseAnalysisRequest getExpenseAnalysisRequest);

    /**
     * 
     * Gets the results for an Amazon Textract asynchronous operation that analyzes invoices and receipts. Amazon
     * Textract finds contact information, items purchased, and vendor name, from input invoices and receipts.
     * 
     * 
     * You start asynchronous invoice/receipt analysis by calling StartExpenseAnalysis, which returns a job
     * identifier (JobId). Upon completion of the invoice/receipt analysis, Amazon Textract publishes the
     * completion status to the Amazon Simple Notification Service (Amazon SNS) topic. This topic must be registered in
     * the initial call to StartExpenseAnalysis. To get the results of the invoice/receipt analysis
     * operation, first ensure that the status value published to the Amazon SNS topic is SUCCEEDED. If so,
     * call GetExpenseAnalysis, and pass the job identifier (JobId) from the initial call to
     * StartExpenseAnalysis.
     * 
     * 
     * 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
     * GetExpenseAnalysis, and populate the NextToken request parameter with the token value
     * that's returned from the previous call to GetExpenseAnalysis.
     * 
     * 
     * For more information, see Analyzing Invoices and Receipts.
     * 
     * 
     * @param getExpenseAnalysisRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetExpenseAnalysis operation returned by the service.
     * @sample AmazonTextractAsyncHandler.GetExpenseAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getExpenseAnalysisAsync(GetExpenseAnalysisRequest getExpenseAnalysisRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Gets the results for an Amazon Textract asynchronous operation that analyzes text in a lending document.
     * 
     * 
     * You start asynchronous text analysis by calling StartLendingAnalysis, 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
     * StartLendingAnalysis.
     * 
     * 
     * 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 GetLendingAnalysis, and pass the job identifier (JobId) from the
     * initial call to StartLendingAnalysis.
     * 
     * 
     * @param getLendingAnalysisRequest
     * @return A Java Future containing the result of the GetLendingAnalysis operation returned by the service.
     * @sample AmazonTextractAsync.GetLendingAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getLendingAnalysisAsync(GetLendingAnalysisRequest getLendingAnalysisRequest);

    /**
     * 
     * Gets the results for an Amazon Textract asynchronous operation that analyzes text in a lending document.
     * 
     * 
     * You start asynchronous text analysis by calling StartLendingAnalysis, 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
     * StartLendingAnalysis.
     * 
     * 
     * 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 GetLendingAnalysis, and pass the job identifier (JobId) from the
     * initial call to StartLendingAnalysis.
     * 
     * 
     * @param getLendingAnalysisRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetLendingAnalysis operation returned by the service.
     * @sample AmazonTextractAsyncHandler.GetLendingAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getLendingAnalysisAsync(GetLendingAnalysisRequest getLendingAnalysisRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Gets summarized results for the StartLendingAnalysis operation, which analyzes text in a lending
     * document. The returned summary consists of information about documents grouped together by a common document
     * type. Information like detected signatures, page numbers, and split documents is returned with respect to the
     * type of grouped document.
     * 
     * 
     * You start asynchronous text analysis by calling StartLendingAnalysis, 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
     * StartLendingAnalysis.
     * 
     * 
     * 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 GetLendingAnalysisSummary, and pass the job identifier (
     * JobId) from the initial call to StartLendingAnalysis.
     * 
     * 
     * @param getLendingAnalysisSummaryRequest
     * @return A Java Future containing the result of the GetLendingAnalysisSummary operation returned by the service.
     * @sample AmazonTextractAsync.GetLendingAnalysisSummary
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getLendingAnalysisSummaryAsync(
            GetLendingAnalysisSummaryRequest getLendingAnalysisSummaryRequest);

    /**
     * 
     * Gets summarized results for the StartLendingAnalysis operation, which analyzes text in a lending
     * document. The returned summary consists of information about documents grouped together by a common document
     * type. Information like detected signatures, page numbers, and split documents is returned with respect to the
     * type of grouped document.
     * 
     * 
     * You start asynchronous text analysis by calling StartLendingAnalysis, 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
     * StartLendingAnalysis.
     * 
     * 
     * 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 GetLendingAnalysisSummary, and pass the job identifier (
     * JobId) from the initial call to StartLendingAnalysis.
     * 
     * 
     * @param getLendingAnalysisSummaryRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetLendingAnalysisSummary operation returned by the service.
     * @sample AmazonTextractAsyncHandler.GetLendingAnalysisSummary
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getLendingAnalysisSummaryAsync(
            GetLendingAnalysisSummaryRequest getLendingAnalysisSummaryRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * List all version of an adapter that meet the specified filtration criteria.
     * 
     * 
     * @param listAdapterVersionsRequest
     * @return A Java Future containing the result of the ListAdapterVersions operation returned by the service.
     * @sample AmazonTextractAsync.ListAdapterVersions
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future listAdapterVersionsAsync(ListAdapterVersionsRequest listAdapterVersionsRequest);

    /**
     * 
     * List all version of an adapter that meet the specified filtration criteria.
     * 
     * 
     * @param listAdapterVersionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListAdapterVersions operation returned by the service.
     * @sample AmazonTextractAsyncHandler.ListAdapterVersions
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future listAdapterVersionsAsync(ListAdapterVersionsRequest listAdapterVersionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Lists all adapters that match the specified filtration criteria.
     * 
     * 
     * @param listAdaptersRequest
     * @return A Java Future containing the result of the ListAdapters operation returned by the service.
     * @sample AmazonTextractAsync.ListAdapters
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future listAdaptersAsync(ListAdaptersRequest listAdaptersRequest);

    /**
     * 
     * Lists all adapters that match the specified filtration criteria.
     * 
     * 
     * @param listAdaptersRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListAdapters operation returned by the service.
     * @sample AmazonTextractAsyncHandler.ListAdapters
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future listAdaptersAsync(ListAdaptersRequest listAdaptersRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Lists all tags for an Amazon Textract resource.
     * 
     * 
     * @param listTagsForResourceRequest
     * @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
     * @sample AmazonTextractAsync.ListTagsForResource
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest listTagsForResourceRequest);

    /**
     * 
     * Lists all tags for an Amazon Textract resource.
     * 
     * 
     * @param listTagsForResourceRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
     * @sample AmazonTextractAsyncHandler.ListTagsForResource
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest listTagsForResourceRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * 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, TIFF, 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.
     * 
     * 
     * @param startDocumentAnalysisRequest
     * @return A Java Future containing the result of the StartDocumentAnalysis operation returned by the service.
     * @sample AmazonTextractAsync.StartDocumentAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future startDocumentAnalysisAsync(StartDocumentAnalysisRequest startDocumentAnalysisRequest);

    /**
     * 
     * 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, TIFF, 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.
     * 
     * 
     * @param startDocumentAnalysisRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the StartDocumentAnalysis operation returned by the service.
     * @sample AmazonTextractAsyncHandler.StartDocumentAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future startDocumentAnalysisAsync(StartDocumentAnalysisRequest startDocumentAnalysisRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * 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, TIFF, 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.
     * 
     * 
     * @param startDocumentTextDetectionRequest
     * @return A Java Future containing the result of the StartDocumentTextDetection operation returned by the service.
     * @sample AmazonTextractAsync.StartDocumentTextDetection
     * @see AWS API Documentation
     */
    java.util.concurrent.Future startDocumentTextDetectionAsync(
            StartDocumentTextDetectionRequest startDocumentTextDetectionRequest);

    /**
     * 
     * 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, TIFF, 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.
     * 
     * 
     * @param startDocumentTextDetectionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the StartDocumentTextDetection operation returned by the service.
     * @sample AmazonTextractAsyncHandler.StartDocumentTextDetection
     * @see AWS API Documentation
     */
    java.util.concurrent.Future startDocumentTextDetectionAsync(
            StartDocumentTextDetectionRequest startDocumentTextDetectionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Starts the asynchronous analysis of invoices or receipts for data like contact information, items purchased, and
     * vendor names.
     * 
     * 
     * StartExpenseAnalysis can analyze text in documents that are in JPEG, PNG, and PDF format. The
     * documents must be stored in an Amazon S3 bucket. Use the DocumentLocation parameter to specify the name of
     * your S3 bucket and the name of the document in that bucket.
     * 
     * 
     * StartExpenseAnalysis returns a job identifier (JobId) that you will provide to
     * GetExpenseAnalysis to retrieve the results of the operation. When the analysis of the input
     * invoices/receipts is finished, Amazon Textract publishes a completion status to the Amazon Simple Notification
     * Service (Amazon SNS) topic that you provide to the NotificationChannel. To obtain the results of the
     * invoice and receipt analysis operation, ensure that the status value published to the Amazon SNS topic is
     * SUCCEEDED. If so, call GetExpenseAnalysis, and pass the job identifier (JobId)
     * that was returned by your call to StartExpenseAnalysis.
     * 
     * 
     * For more information, see Analyzing Invoices and Receipts.
     * 
     * 
     * @param startExpenseAnalysisRequest
     * @return A Java Future containing the result of the StartExpenseAnalysis operation returned by the service.
     * @sample AmazonTextractAsync.StartExpenseAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future startExpenseAnalysisAsync(StartExpenseAnalysisRequest startExpenseAnalysisRequest);

    /**
     * 
     * Starts the asynchronous analysis of invoices or receipts for data like contact information, items purchased, and
     * vendor names.
     * 
     * 
     * StartExpenseAnalysis can analyze text in documents that are in JPEG, PNG, and PDF format. The
     * documents must be stored in an Amazon S3 bucket. Use the DocumentLocation parameter to specify the name of
     * your S3 bucket and the name of the document in that bucket.
     * 
     * 
     * StartExpenseAnalysis returns a job identifier (JobId) that you will provide to
     * GetExpenseAnalysis to retrieve the results of the operation. When the analysis of the input
     * invoices/receipts is finished, Amazon Textract publishes a completion status to the Amazon Simple Notification
     * Service (Amazon SNS) topic that you provide to the NotificationChannel. To obtain the results of the
     * invoice and receipt analysis operation, ensure that the status value published to the Amazon SNS topic is
     * SUCCEEDED. If so, call GetExpenseAnalysis, and pass the job identifier (JobId)
     * that was returned by your call to StartExpenseAnalysis.
     * 
     * 
     * For more information, see Analyzing Invoices and Receipts.
     * 
     * 
     * @param startExpenseAnalysisRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the StartExpenseAnalysis operation returned by the service.
     * @sample AmazonTextractAsyncHandler.StartExpenseAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future startExpenseAnalysisAsync(StartExpenseAnalysisRequest startExpenseAnalysisRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Starts the classification and analysis of an input document. StartLendingAnalysis initiates the
     * classification and analysis of a packet of lending documents. StartLendingAnalysis operates on a
     * document file located in an Amazon S3 bucket.
     * 
     * 
     * StartLendingAnalysis can analyze text in documents that are in one of the following formats: JPEG,
     * PNG, TIFF, PDF. Use DocumentLocation to specify the bucket name and the file name of the document.
     * 
     * 
     * StartLendingAnalysis returns a job identifier (JobId) that you use to get the results
     * of the operation. When the 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 the status is SUCCEEDED you can call either GetLendingAnalysis or
     * GetLendingAnalysisSummary and provide the JobId to obtain the results of the analysis.
     * 
     * 
     * If using OutputConfig to specify an Amazon S3 bucket, the output will be contained within the
     * specified prefix in a directory labeled with the job-id. In the directory there are 3 sub-directories:
     * 
     * 
     * 
     * 
     * detailedResponse (contains the GetLendingAnalysis response)
     * 
     * 
     * 
     * 
     * summaryResponse (for the GetLendingAnalysisSummary response)
     * 
     * 
     * 
     * 
     * splitDocuments (documents split across logical boundaries)
     * 
     * 
     * 
     * 
     * @param startLendingAnalysisRequest
     * @return A Java Future containing the result of the StartLendingAnalysis operation returned by the service.
     * @sample AmazonTextractAsync.StartLendingAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future startLendingAnalysisAsync(StartLendingAnalysisRequest startLendingAnalysisRequest);

    /**
     * 
     * Starts the classification and analysis of an input document. StartLendingAnalysis initiates the
     * classification and analysis of a packet of lending documents. StartLendingAnalysis operates on a
     * document file located in an Amazon S3 bucket.
     * 
     * 
     * StartLendingAnalysis can analyze text in documents that are in one of the following formats: JPEG,
     * PNG, TIFF, PDF. Use DocumentLocation to specify the bucket name and the file name of the document.
     * 
     * 
     * StartLendingAnalysis returns a job identifier (JobId) that you use to get the results
     * of the operation. When the 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 the status is SUCCEEDED you can call either GetLendingAnalysis or
     * GetLendingAnalysisSummary and provide the JobId to obtain the results of the analysis.
     * 
     * 
     * If using OutputConfig to specify an Amazon S3 bucket, the output will be contained within the
     * specified prefix in a directory labeled with the job-id. In the directory there are 3 sub-directories:
     * 
     * 
     * 
     * 
     * detailedResponse (contains the GetLendingAnalysis response)
     * 
     * 
     * 
     * 
     * summaryResponse (for the GetLendingAnalysisSummary response)
     * 
     * 
     * 
     * 
     * splitDocuments (documents split across logical boundaries)
     * 
     * 
     * 
     * 
     * @param startLendingAnalysisRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the StartLendingAnalysis operation returned by the service.
     * @sample AmazonTextractAsyncHandler.StartLendingAnalysis
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future startLendingAnalysisAsync(StartLendingAnalysisRequest startLendingAnalysisRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Adds one or more tags to the specified resource.
     * 
     * 
     * @param tagResourceRequest
     * @return A Java Future containing the result of the TagResource operation returned by the service.
     * @sample AmazonTextractAsync.TagResource
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest);

    /**
     * 
     * Adds one or more tags to the specified resource.
     * 
     * 
     * @param tagResourceRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the TagResource operation returned by the service.
     * @sample AmazonTextractAsyncHandler.TagResource
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future tagResourceAsync(TagResourceRequest tagResourceRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Removes any tags with the specified keys from the specified resource.
     * 
     * 
     * @param untagResourceRequest
     * @return A Java Future containing the result of the UntagResource operation returned by the service.
     * @sample AmazonTextractAsync.UntagResource
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest);

    /**
     * 
     * Removes any tags with the specified keys from the specified resource.
     * 
     * 
     * @param untagResourceRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UntagResource operation returned by the service.
     * @sample AmazonTextractAsyncHandler.UntagResource
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future untagResourceAsync(UntagResourceRequest untagResourceRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * 
     * Update the configuration for an adapter. FeatureTypes configurations cannot be updated. At least one new
     * parameter must be specified as an argument.
     * 
     * 
     * @param updateAdapterRequest
     * @return A Java Future containing the result of the UpdateAdapter operation returned by the service.
     * @sample AmazonTextractAsync.UpdateAdapter
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future updateAdapterAsync(UpdateAdapterRequest updateAdapterRequest);

    /**
     * 
     * Update the configuration for an adapter. FeatureTypes configurations cannot be updated. At least one new
     * parameter must be specified as an argument.
     * 
     * 
     * @param updateAdapterRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateAdapter operation returned by the service.
     * @sample AmazonTextractAsyncHandler.UpdateAdapter
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future updateAdapterAsync(UpdateAdapterRequest updateAdapterRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

}