Documentation

Overview

    Package comprehend provides the API client, operations, and parameter types for Amazon Comprehend.

    Amazon Comprehend is an AWS service for gaining insight into the content of documents. Use these actions to determine the topics contained in your documents, the topics they discuss, the predominant sentiment expressed in them, the predominant language used, and more.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-11-27"
    View Source
    const ServiceID = "Comprehend"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type BatchDetectDominantLanguageInput

          type BatchDetectDominantLanguageInput struct {
          
          	// A list containing the text of the input documents. The list can contain a
          	// maximum of 25 documents. Each document should contain at least 20 characters and
          	// must contain fewer than 5,000 bytes of UTF-8 encoded characters.
          	//
          	// This member is required.
          	TextList []string
          }

          type BatchDetectDominantLanguageOutput

          type BatchDetectDominantLanguageOutput struct {
          
          	// A list containing one object for each document that contained an error. The
          	// results are sorted in ascending order by the Index field and match the order of
          	// the documents in the input list. If there are no errors in the batch, the
          	// ErrorList is empty.
          	//
          	// This member is required.
          	ErrorList []types.BatchItemError
          
          	// A list of objects containing the results of the operation. The results are
          	// sorted in ascending order by the Index field and match the order of the
          	// documents in the input list. If all of the documents contain an error, the
          	// ResultList is empty.
          	//
          	// This member is required.
          	ResultList []types.BatchDetectDominantLanguageItemResult
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type BatchDetectEntitiesInput

          type BatchDetectEntitiesInput struct {
          
          	// The language of the input documents. You can specify any of the primary
          	// languages supported by Amazon Comprehend. All documents must be in the same
          	// language.
          	//
          	// This member is required.
          	LanguageCode types.LanguageCode
          
          	// A list containing the text of the input documents. The list can contain a
          	// maximum of 25 documents. Each document must contain fewer than 5,000 bytes of
          	// UTF-8 encoded characters.
          	//
          	// This member is required.
          	TextList []string
          }

          type BatchDetectEntitiesOutput

          type BatchDetectEntitiesOutput struct {
          
          	// A list containing one object for each document that contained an error. The
          	// results are sorted in ascending order by the Index field and match the order of
          	// the documents in the input list. If there are no errors in the batch, the
          	// ErrorList is empty.
          	//
          	// This member is required.
          	ErrorList []types.BatchItemError
          
          	// A list of objects containing the results of the operation. The results are
          	// sorted in ascending order by the Index field and match the order of the
          	// documents in the input list. If all of the documents contain an error, the
          	// ResultList is empty.
          	//
          	// This member is required.
          	ResultList []types.BatchDetectEntitiesItemResult
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type BatchDetectKeyPhrasesInput

          type BatchDetectKeyPhrasesInput struct {
          
          	// The language of the input documents. You can specify any of the primary
          	// languages supported by Amazon Comprehend. All documents must be in the same
          	// language.
          	//
          	// This member is required.
          	LanguageCode types.LanguageCode
          
          	// A list containing the text of the input documents. The list can contain a
          	// maximum of 25 documents. Each document must contain fewer that 5,000 bytes of
          	// UTF-8 encoded characters.
          	//
          	// This member is required.
          	TextList []string
          }

          type BatchDetectKeyPhrasesOutput

          type BatchDetectKeyPhrasesOutput struct {
          
          	// A list containing one object for each document that contained an error. The
          	// results are sorted in ascending order by the Index field and match the order of
          	// the documents in the input list. If there are no errors in the batch, the
          	// ErrorList is empty.
          	//
          	// This member is required.
          	ErrorList []types.BatchItemError
          
          	// A list of objects containing the results of the operation. The results are
          	// sorted in ascending order by the Index field and match the order of the
          	// documents in the input list. If all of the documents contain an error, the
          	// ResultList is empty.
          	//
          	// This member is required.
          	ResultList []types.BatchDetectKeyPhrasesItemResult
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type BatchDetectSentimentInput

          type BatchDetectSentimentInput struct {
          
          	// The language of the input documents. You can specify any of the primary
          	// languages supported by Amazon Comprehend. All documents must be in the same
          	// language.
          	//
          	// This member is required.
          	LanguageCode types.LanguageCode
          
          	// A list containing the text of the input documents. The list can contain a
          	// maximum of 25 documents. Each document must contain fewer that 5,000 bytes of
          	// UTF-8 encoded characters.
          	//
          	// This member is required.
          	TextList []string
          }

          type BatchDetectSentimentOutput

          type BatchDetectSentimentOutput struct {
          
          	// A list containing one object for each document that contained an error. The
          	// results are sorted in ascending order by the Index field and match the order of
          	// the documents in the input list. If there are no errors in the batch, the
          	// ErrorList is empty.
          	//
          	// This member is required.
          	ErrorList []types.BatchItemError
          
          	// A list of objects containing the results of the operation. The results are
          	// sorted in ascending order by the Index field and match the order of the
          	// documents in the input list. If all of the documents contain an error, the
          	// ResultList is empty.
          	//
          	// This member is required.
          	ResultList []types.BatchDetectSentimentItemResult
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type BatchDetectSyntaxInput

          type BatchDetectSyntaxInput struct {
          
          	// The language of the input documents. You can specify any of the following
          	// languages supported by Amazon Comprehend: German ("de"), English ("en"), Spanish
          	// ("es"), French ("fr"), Italian ("it"), or Portuguese ("pt"). All documents must
          	// be in the same language.
          	//
          	// This member is required.
          	LanguageCode types.SyntaxLanguageCode
          
          	// A list containing the text of the input documents. The list can contain a
          	// maximum of 25 documents. Each document must contain fewer that 5,000 bytes of
          	// UTF-8 encoded characters.
          	//
          	// This member is required.
          	TextList []string
          }

          type BatchDetectSyntaxOutput

          type BatchDetectSyntaxOutput struct {
          
          	// A list containing one object for each document that contained an error. The
          	// results are sorted in ascending order by the Index field and match the order of
          	// the documents in the input list. If there are no errors in the batch, the
          	// ErrorList is empty.
          	//
          	// This member is required.
          	ErrorList []types.BatchItemError
          
          	// A list of objects containing the results of the operation. The results are
          	// sorted in ascending order by the Index field and match the order of the
          	// documents in the input list. If all of the documents contain an error, the
          	// ResultList is empty.
          	//
          	// This member is required.
          	ResultList []types.BatchDetectSyntaxItemResult
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type ClassifyDocumentInput

          type ClassifyDocumentInput struct {
          
          	// The Amazon Resource Number (ARN) of the endpoint.
          	//
          	// This member is required.
          	EndpointArn *string
          
          	// The document text to be analyzed.
          	//
          	// This member is required.
          	Text *string
          }

          type ClassifyDocumentOutput

          type ClassifyDocumentOutput struct {
          
          	// The classes used by the document being analyzed. These are used for multi-class
          	// trained models. Individual classes are mutually exclusive and each document is
          	// expected to have only a single class assigned to it. For example, an animal can
          	// be a dog or a cat, but not both at the same time.
          	Classes []types.DocumentClass
          
          	// The labels used the document being analyzed. These are used for multi-label
          	// trained models. Individual labels represent different categories that are
          	// related in some manner and are not mutually exclusive. For example, a movie can
          	// be just an action movie, or it can be an action movie, a science fiction movie,
          	// and a comedy, all at the same time.
          	Labels []types.DocumentLabel
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for Amazon Comprehend.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) BatchDetectDominantLanguage

                func (c *Client) BatchDetectDominantLanguage(ctx context.Context, params *BatchDetectDominantLanguageInput, optFns ...func(*Options)) (*BatchDetectDominantLanguageOutput, error)

                  Determines the dominant language of the input text for a batch of documents. For a list of languages that Amazon Comprehend can detect, see Amazon Comprehend Supported Languages (https://docs.aws.amazon.com/comprehend/latest/dg/how-languages.html).

                  func (*Client) BatchDetectEntities

                  func (c *Client) BatchDetectEntities(ctx context.Context, params *BatchDetectEntitiesInput, optFns ...func(*Options)) (*BatchDetectEntitiesOutput, error)

                    Inspects the text of a batch of documents for named entities and returns information about them. For more information about named entities, see how-entities

                    func (*Client) BatchDetectKeyPhrases

                    func (c *Client) BatchDetectKeyPhrases(ctx context.Context, params *BatchDetectKeyPhrasesInput, optFns ...func(*Options)) (*BatchDetectKeyPhrasesOutput, error)

                      Detects the key noun phrases found in a batch of documents.

                      func (*Client) BatchDetectSentiment

                      func (c *Client) BatchDetectSentiment(ctx context.Context, params *BatchDetectSentimentInput, optFns ...func(*Options)) (*BatchDetectSentimentOutput, error)

                        Inspects a batch of documents and returns an inference of the prevailing sentiment, POSITIVE, NEUTRAL, MIXED, or NEGATIVE, in each one.

                        func (*Client) BatchDetectSyntax

                        func (c *Client) BatchDetectSyntax(ctx context.Context, params *BatchDetectSyntaxInput, optFns ...func(*Options)) (*BatchDetectSyntaxOutput, error)

                          Inspects the text of a batch of documents for the syntax and part of speech of the words in the document and returns information about them. For more information, see how-syntax.

                          func (*Client) ClassifyDocument

                          func (c *Client) ClassifyDocument(ctx context.Context, params *ClassifyDocumentInput, optFns ...func(*Options)) (*ClassifyDocumentOutput, error)

                            Creates a new document classification request to analyze a single document in real-time, using a previously created and trained custom model and an endpoint.

                            func (*Client) ContainsPiiEntities

                            func (c *Client) ContainsPiiEntities(ctx context.Context, params *ContainsPiiEntitiesInput, optFns ...func(*Options)) (*ContainsPiiEntitiesOutput, error)

                              Analyzes input text for the presence of personally identifiable information (PII) and returns the labels of identified PII entity types such as name, address, bank account number, or phone number.

                              func (*Client) CreateDocumentClassifier

                              func (c *Client) CreateDocumentClassifier(ctx context.Context, params *CreateDocumentClassifierInput, optFns ...func(*Options)) (*CreateDocumentClassifierOutput, error)

                                Creates a new document classifier that you can use to categorize documents. To create a classifier, you provide a set of training documents that labeled with the categories that you want to use. After the classifier is trained you can use it to categorize a set of labeled documents into the categories. For more information, see how-document-classification.

                                func (*Client) CreateEndpoint

                                func (c *Client) CreateEndpoint(ctx context.Context, params *CreateEndpointInput, optFns ...func(*Options)) (*CreateEndpointOutput, error)

                                  Creates a model-specific endpoint for synchronous inference for a previously trained custom model

                                  func (*Client) CreateEntityRecognizer

                                  func (c *Client) CreateEntityRecognizer(ctx context.Context, params *CreateEntityRecognizerInput, optFns ...func(*Options)) (*CreateEntityRecognizerOutput, error)

                                    Creates an entity recognizer using submitted files. After your CreateEntityRecognizer request is submitted, you can check job status using the API.

                                    func (*Client) DeleteDocumentClassifier

                                    func (c *Client) DeleteDocumentClassifier(ctx context.Context, params *DeleteDocumentClassifierInput, optFns ...func(*Options)) (*DeleteDocumentClassifierOutput, error)

                                      Deletes a previously created document classifier Only those classifiers that are in terminated states (IN_ERROR, TRAINED) will be deleted. If an active inference job is using the model, a ResourceInUseException will be returned. This is an asynchronous action that puts the classifier into a DELETING state, and it is then removed by a background job. Once removed, the classifier disappears from your account and is no longer available for use.

                                      func (*Client) DeleteEndpoint

                                      func (c *Client) DeleteEndpoint(ctx context.Context, params *DeleteEndpointInput, optFns ...func(*Options)) (*DeleteEndpointOutput, error)

                                        Deletes a model-specific endpoint for a previously-trained custom model. All endpoints must be deleted in order for the model to be deleted.

                                        func (*Client) DeleteEntityRecognizer

                                        func (c *Client) DeleteEntityRecognizer(ctx context.Context, params *DeleteEntityRecognizerInput, optFns ...func(*Options)) (*DeleteEntityRecognizerOutput, error)

                                          Deletes an entity recognizer. Only those recognizers that are in terminated states (IN_ERROR, TRAINED) will be deleted. If an active inference job is using the model, a ResourceInUseException will be returned. This is an asynchronous action that puts the recognizer into a DELETING state, and it is then removed by a background job. Once removed, the recognizer disappears from your account and is no longer available for use.

                                          func (*Client) DescribeDocumentClassificationJob

                                          func (c *Client) DescribeDocumentClassificationJob(ctx context.Context, params *DescribeDocumentClassificationJobInput, optFns ...func(*Options)) (*DescribeDocumentClassificationJobOutput, error)

                                            Gets the properties associated with a document classification job. Use this operation to get the status of a classification job.

                                            func (*Client) DescribeDocumentClassifier

                                            func (c *Client) DescribeDocumentClassifier(ctx context.Context, params *DescribeDocumentClassifierInput, optFns ...func(*Options)) (*DescribeDocumentClassifierOutput, error)

                                              Gets the properties associated with a document classifier.

                                              func (*Client) DescribeDominantLanguageDetectionJob

                                              func (c *Client) DescribeDominantLanguageDetectionJob(ctx context.Context, params *DescribeDominantLanguageDetectionJobInput, optFns ...func(*Options)) (*DescribeDominantLanguageDetectionJobOutput, error)

                                                Gets the properties associated with a dominant language detection job. Use this operation to get the status of a detection job.

                                                func (*Client) DescribeEndpoint

                                                func (c *Client) DescribeEndpoint(ctx context.Context, params *DescribeEndpointInput, optFns ...func(*Options)) (*DescribeEndpointOutput, error)

                                                  Gets the properties associated with a specific endpoint. Use this operation to get the status of an endpoint.

                                                  func (*Client) DescribeEntitiesDetectionJob

                                                  func (c *Client) DescribeEntitiesDetectionJob(ctx context.Context, params *DescribeEntitiesDetectionJobInput, optFns ...func(*Options)) (*DescribeEntitiesDetectionJobOutput, error)

                                                    Gets the properties associated with an entities detection job. Use this operation to get the status of a detection job.

                                                    func (*Client) DescribeEntityRecognizer

                                                    func (c *Client) DescribeEntityRecognizer(ctx context.Context, params *DescribeEntityRecognizerInput, optFns ...func(*Options)) (*DescribeEntityRecognizerOutput, error)

                                                      Provides details about an entity recognizer including status, S3 buckets containing training data, recognizer metadata, metrics, and so on.

                                                      func (*Client) DescribeEventsDetectionJob

                                                      func (c *Client) DescribeEventsDetectionJob(ctx context.Context, params *DescribeEventsDetectionJobInput, optFns ...func(*Options)) (*DescribeEventsDetectionJobOutput, error)

                                                        Gets the status and details of an events detection job.

                                                        func (*Client) DescribeKeyPhrasesDetectionJob

                                                        func (c *Client) DescribeKeyPhrasesDetectionJob(ctx context.Context, params *DescribeKeyPhrasesDetectionJobInput, optFns ...func(*Options)) (*DescribeKeyPhrasesDetectionJobOutput, error)

                                                          Gets the properties associated with a key phrases detection job. Use this operation to get the status of a detection job.

                                                          func (*Client) DescribePiiEntitiesDetectionJob

                                                          func (c *Client) DescribePiiEntitiesDetectionJob(ctx context.Context, params *DescribePiiEntitiesDetectionJobInput, optFns ...func(*Options)) (*DescribePiiEntitiesDetectionJobOutput, error)

                                                            Gets the properties associated with a PII entities detection job. For example, you can use this operation to get the job status.

                                                            func (*Client) DescribeSentimentDetectionJob

                                                            func (c *Client) DescribeSentimentDetectionJob(ctx context.Context, params *DescribeSentimentDetectionJobInput, optFns ...func(*Options)) (*DescribeSentimentDetectionJobOutput, error)

                                                              Gets the properties associated with a sentiment detection job. Use this operation to get the status of a detection job.

                                                              func (*Client) DescribeTopicsDetectionJob

                                                              func (c *Client) DescribeTopicsDetectionJob(ctx context.Context, params *DescribeTopicsDetectionJobInput, optFns ...func(*Options)) (*DescribeTopicsDetectionJobOutput, error)

                                                                Gets the properties associated with a topic detection job. Use this operation to get the status of a detection job.

                                                                func (*Client) DetectDominantLanguage

                                                                func (c *Client) DetectDominantLanguage(ctx context.Context, params *DetectDominantLanguageInput, optFns ...func(*Options)) (*DetectDominantLanguageOutput, error)

                                                                  Determines the dominant language of the input text. For a list of languages that Amazon Comprehend can detect, see Amazon Comprehend Supported Languages (https://docs.aws.amazon.com/comprehend/latest/dg/how-languages.html).

                                                                  func (*Client) DetectEntities

                                                                  func (c *Client) DetectEntities(ctx context.Context, params *DetectEntitiesInput, optFns ...func(*Options)) (*DetectEntitiesOutput, error)

                                                                    Inspects text for named entities, and returns information about them. For more information, about named entities, see how-entities.

                                                                    func (*Client) DetectKeyPhrases

                                                                    func (c *Client) DetectKeyPhrases(ctx context.Context, params *DetectKeyPhrasesInput, optFns ...func(*Options)) (*DetectKeyPhrasesOutput, error)

                                                                      Detects the key noun phrases found in the text.

                                                                      func (*Client) DetectPiiEntities

                                                                      func (c *Client) DetectPiiEntities(ctx context.Context, params *DetectPiiEntitiesInput, optFns ...func(*Options)) (*DetectPiiEntitiesOutput, error)

                                                                        Inspects the input text for entities that contain personally identifiable information (PII) and returns information about them.

                                                                        func (*Client) DetectSentiment

                                                                        func (c *Client) DetectSentiment(ctx context.Context, params *DetectSentimentInput, optFns ...func(*Options)) (*DetectSentimentOutput, error)

                                                                          Inspects text and returns an inference of the prevailing sentiment (POSITIVE, NEUTRAL, MIXED, or NEGATIVE).

                                                                          func (*Client) DetectSyntax

                                                                          func (c *Client) DetectSyntax(ctx context.Context, params *DetectSyntaxInput, optFns ...func(*Options)) (*DetectSyntaxOutput, error)

                                                                            Inspects text for syntax and the part of speech of words in the document. For more information, how-syntax.

                                                                            func (*Client) ListDocumentClassificationJobs

                                                                            func (c *Client) ListDocumentClassificationJobs(ctx context.Context, params *ListDocumentClassificationJobsInput, optFns ...func(*Options)) (*ListDocumentClassificationJobsOutput, error)

                                                                              Gets a list of the documentation classification jobs that you have submitted.

                                                                              func (*Client) ListDocumentClassifiers

                                                                              func (c *Client) ListDocumentClassifiers(ctx context.Context, params *ListDocumentClassifiersInput, optFns ...func(*Options)) (*ListDocumentClassifiersOutput, error)

                                                                                Gets a list of the document classifiers that you have created.

                                                                                func (*Client) ListDominantLanguageDetectionJobs

                                                                                func (c *Client) ListDominantLanguageDetectionJobs(ctx context.Context, params *ListDominantLanguageDetectionJobsInput, optFns ...func(*Options)) (*ListDominantLanguageDetectionJobsOutput, error)

                                                                                  Gets a list of the dominant language detection jobs that you have submitted.

                                                                                  func (*Client) ListEndpoints

                                                                                  func (c *Client) ListEndpoints(ctx context.Context, params *ListEndpointsInput, optFns ...func(*Options)) (*ListEndpointsOutput, error)

                                                                                    Gets a list of all existing endpoints that you've created.

                                                                                    func (*Client) ListEntitiesDetectionJobs

                                                                                    func (c *Client) ListEntitiesDetectionJobs(ctx context.Context, params *ListEntitiesDetectionJobsInput, optFns ...func(*Options)) (*ListEntitiesDetectionJobsOutput, error)

                                                                                      Gets a list of the entity detection jobs that you have submitted.

                                                                                      func (*Client) ListEntityRecognizers

                                                                                      func (c *Client) ListEntityRecognizers(ctx context.Context, params *ListEntityRecognizersInput, optFns ...func(*Options)) (*ListEntityRecognizersOutput, error)

                                                                                        Gets a list of the properties of all entity recognizers that you created, including recognizers currently in training. Allows you to filter the list of recognizers based on criteria such as status and submission time. This call returns up to 500 entity recognizers in the list, with a default number of 100 recognizers in the list. The results of this list are not in any particular order. Please get the list and sort locally if needed.

                                                                                        func (*Client) ListEventsDetectionJobs

                                                                                        func (c *Client) ListEventsDetectionJobs(ctx context.Context, params *ListEventsDetectionJobsInput, optFns ...func(*Options)) (*ListEventsDetectionJobsOutput, error)

                                                                                          Gets a list of the events detection jobs that you have submitted.

                                                                                          func (*Client) ListKeyPhrasesDetectionJobs

                                                                                          func (c *Client) ListKeyPhrasesDetectionJobs(ctx context.Context, params *ListKeyPhrasesDetectionJobsInput, optFns ...func(*Options)) (*ListKeyPhrasesDetectionJobsOutput, error)

                                                                                            Get a list of key phrase detection jobs that you have submitted.

                                                                                            func (*Client) ListPiiEntitiesDetectionJobs

                                                                                            func (c *Client) ListPiiEntitiesDetectionJobs(ctx context.Context, params *ListPiiEntitiesDetectionJobsInput, optFns ...func(*Options)) (*ListPiiEntitiesDetectionJobsOutput, error)

                                                                                              Gets a list of the PII entity detection jobs that you have submitted.

                                                                                              func (*Client) ListSentimentDetectionJobs

                                                                                              func (c *Client) ListSentimentDetectionJobs(ctx context.Context, params *ListSentimentDetectionJobsInput, optFns ...func(*Options)) (*ListSentimentDetectionJobsOutput, error)

                                                                                                Gets a list of sentiment detection jobs that you have submitted.

                                                                                                func (*Client) ListTagsForResource

                                                                                                func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                                                                  Lists all tags associated with a given Amazon Comprehend resource.

                                                                                                  func (*Client) ListTopicsDetectionJobs

                                                                                                  func (c *Client) ListTopicsDetectionJobs(ctx context.Context, params *ListTopicsDetectionJobsInput, optFns ...func(*Options)) (*ListTopicsDetectionJobsOutput, error)

                                                                                                    Gets a list of the topic detection jobs that you have submitted.

                                                                                                    func (*Client) StartDocumentClassificationJob

                                                                                                    func (c *Client) StartDocumentClassificationJob(ctx context.Context, params *StartDocumentClassificationJobInput, optFns ...func(*Options)) (*StartDocumentClassificationJobOutput, error)

                                                                                                      Starts an asynchronous document classification job. Use the operation to track the progress of the job.

                                                                                                      func (*Client) StartDominantLanguageDetectionJob

                                                                                                      func (c *Client) StartDominantLanguageDetectionJob(ctx context.Context, params *StartDominantLanguageDetectionJobInput, optFns ...func(*Options)) (*StartDominantLanguageDetectionJobOutput, error)

                                                                                                        Starts an asynchronous dominant language detection job for a collection of documents. Use the operation to track the status of a job.

                                                                                                        func (*Client) StartEntitiesDetectionJob

                                                                                                        func (c *Client) StartEntitiesDetectionJob(ctx context.Context, params *StartEntitiesDetectionJobInput, optFns ...func(*Options)) (*StartEntitiesDetectionJobOutput, error)

                                                                                                          Starts an asynchronous entity detection job for a collection of documents. Use the operation to track the status of a job. This API can be used for either standard entity detection or custom entity recognition. In order to be used for custom entity recognition, the optional EntityRecognizerArn must be used in order to provide access to the recognizer being used to detect the custom entity.

                                                                                                          func (*Client) StartEventsDetectionJob

                                                                                                          func (c *Client) StartEventsDetectionJob(ctx context.Context, params *StartEventsDetectionJobInput, optFns ...func(*Options)) (*StartEventsDetectionJobOutput, error)

                                                                                                            Starts an asynchronous event detection job for a collection of documents.

                                                                                                            func (*Client) StartKeyPhrasesDetectionJob

                                                                                                            func (c *Client) StartKeyPhrasesDetectionJob(ctx context.Context, params *StartKeyPhrasesDetectionJobInput, optFns ...func(*Options)) (*StartKeyPhrasesDetectionJobOutput, error)

                                                                                                              Starts an asynchronous key phrase detection job for a collection of documents. Use the operation to track the status of a job.

                                                                                                              func (*Client) StartPiiEntitiesDetectionJob

                                                                                                              func (c *Client) StartPiiEntitiesDetectionJob(ctx context.Context, params *StartPiiEntitiesDetectionJobInput, optFns ...func(*Options)) (*StartPiiEntitiesDetectionJobOutput, error)

                                                                                                                Starts an asynchronous PII entity detection job for a collection of documents.

                                                                                                                func (*Client) StartSentimentDetectionJob

                                                                                                                func (c *Client) StartSentimentDetectionJob(ctx context.Context, params *StartSentimentDetectionJobInput, optFns ...func(*Options)) (*StartSentimentDetectionJobOutput, error)

                                                                                                                  Starts an asynchronous sentiment detection job for a collection of documents. use the operation to track the status of a job.

                                                                                                                  func (*Client) StartTopicsDetectionJob

                                                                                                                  func (c *Client) StartTopicsDetectionJob(ctx context.Context, params *StartTopicsDetectionJobInput, optFns ...func(*Options)) (*StartTopicsDetectionJobOutput, error)

                                                                                                                    Starts an asynchronous topic detection job. Use the DescribeTopicDetectionJob operation to track the status of a job.

                                                                                                                    func (*Client) StopDominantLanguageDetectionJob

                                                                                                                    func (c *Client) StopDominantLanguageDetectionJob(ctx context.Context, params *StopDominantLanguageDetectionJobInput, optFns ...func(*Options)) (*StopDominantLanguageDetectionJobOutput, error)

                                                                                                                      Stops a dominant language detection job in progress. If the job state is IN_PROGRESS the job is marked for termination and put into the STOP_REQUESTED state. If the job completes before it can be stopped, it is put into the COMPLETED state; otherwise the job is stopped and put into the STOPPED state. If the job is in the COMPLETED or FAILED state when you call the StopDominantLanguageDetectionJob operation, the operation returns a 400 Internal Request Exception. When a job is stopped, any documents already processed are written to the output location.

                                                                                                                      func (*Client) StopEntitiesDetectionJob

                                                                                                                      func (c *Client) StopEntitiesDetectionJob(ctx context.Context, params *StopEntitiesDetectionJobInput, optFns ...func(*Options)) (*StopEntitiesDetectionJobOutput, error)

                                                                                                                        Stops an entities detection job in progress. If the job state is IN_PROGRESS the job is marked for termination and put into the STOP_REQUESTED state. If the job completes before it can be stopped, it is put into the COMPLETED state; otherwise the job is stopped and put into the STOPPED state. If the job is in the COMPLETED or FAILED state when you call the StopDominantLanguageDetectionJob operation, the operation returns a 400 Internal Request Exception. When a job is stopped, any documents already processed are written to the output location.

                                                                                                                        func (*Client) StopEventsDetectionJob

                                                                                                                        func (c *Client) StopEventsDetectionJob(ctx context.Context, params *StopEventsDetectionJobInput, optFns ...func(*Options)) (*StopEventsDetectionJobOutput, error)

                                                                                                                          Stops an events detection job in progress.

                                                                                                                          func (*Client) StopKeyPhrasesDetectionJob

                                                                                                                          func (c *Client) StopKeyPhrasesDetectionJob(ctx context.Context, params *StopKeyPhrasesDetectionJobInput, optFns ...func(*Options)) (*StopKeyPhrasesDetectionJobOutput, error)

                                                                                                                            Stops a key phrases detection job in progress. If the job state is IN_PROGRESS the job is marked for termination and put into the STOP_REQUESTED state. If the job completes before it can be stopped, it is put into the COMPLETED state; otherwise the job is stopped and put into the STOPPED state. If the job is in the COMPLETED or FAILED state when you call the StopDominantLanguageDetectionJob operation, the operation returns a 400 Internal Request Exception. When a job is stopped, any documents already processed are written to the output location.

                                                                                                                            func (*Client) StopPiiEntitiesDetectionJob

                                                                                                                            func (c *Client) StopPiiEntitiesDetectionJob(ctx context.Context, params *StopPiiEntitiesDetectionJobInput, optFns ...func(*Options)) (*StopPiiEntitiesDetectionJobOutput, error)

                                                                                                                              Stops a PII entities detection job in progress.

                                                                                                                              func (*Client) StopSentimentDetectionJob

                                                                                                                              func (c *Client) StopSentimentDetectionJob(ctx context.Context, params *StopSentimentDetectionJobInput, optFns ...func(*Options)) (*StopSentimentDetectionJobOutput, error)

                                                                                                                                Stops a sentiment detection job in progress. If the job state is IN_PROGRESS the job is marked for termination and put into the STOP_REQUESTED state. If the job completes before it can be stopped, it is put into the COMPLETED state; otherwise the job is be stopped and put into the STOPPED state. If the job is in the COMPLETED or FAILED state when you call the StopDominantLanguageDetectionJob operation, the operation returns a 400 Internal Request Exception. When a job is stopped, any documents already processed are written to the output location.

                                                                                                                                func (*Client) StopTrainingDocumentClassifier

                                                                                                                                func (c *Client) StopTrainingDocumentClassifier(ctx context.Context, params *StopTrainingDocumentClassifierInput, optFns ...func(*Options)) (*StopTrainingDocumentClassifierOutput, error)

                                                                                                                                  Stops a document classifier training job while in progress. If the training job state is TRAINING, the job is marked for termination and put into the STOP_REQUESTED state. If the training job completes before it can be stopped, it is put into the TRAINED; otherwise the training job is stopped and put into the STOPPED state and the service sends back an HTTP 200 response with an empty HTTP body.

                                                                                                                                  func (*Client) StopTrainingEntityRecognizer

                                                                                                                                  func (c *Client) StopTrainingEntityRecognizer(ctx context.Context, params *StopTrainingEntityRecognizerInput, optFns ...func(*Options)) (*StopTrainingEntityRecognizerOutput, error)

                                                                                                                                    Stops an entity recognizer training job while in progress. If the training job state is TRAINING, the job is marked for termination and put into the STOP_REQUESTED state. If the training job completes before it can be stopped, it is put into the TRAINED; otherwise the training job is stopped and putted into the STOPPED state and the service sends back an HTTP 200 response with an empty HTTP body.

                                                                                                                                    func (*Client) TagResource

                                                                                                                                    func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                                                                                                      Associates a specific tag with an Amazon Comprehend resource. A tag is a key-value pair that adds as a metadata to a resource used by Amazon Comprehend. For example, a tag with "Sales" as the key might be added to a resource to indicate its use by the sales department.

                                                                                                                                      func (*Client) UntagResource

                                                                                                                                      func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                                                                                                        Removes a specific tag associated with an Amazon Comprehend resource.

                                                                                                                                        func (*Client) UpdateEndpoint

                                                                                                                                        func (c *Client) UpdateEndpoint(ctx context.Context, params *UpdateEndpointInput, optFns ...func(*Options)) (*UpdateEndpointOutput, error)

                                                                                                                                          Updates information about the specified endpoint.

                                                                                                                                          type ContainsPiiEntitiesInput

                                                                                                                                          type ContainsPiiEntitiesInput struct {
                                                                                                                                          
                                                                                                                                          	// The language of the input documents.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	LanguageCode types.LanguageCode
                                                                                                                                          
                                                                                                                                          	// Creates a new document classification request to analyze a single document in
                                                                                                                                          	// real-time, returning personally identifiable information (PII) entity labels.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Text *string
                                                                                                                                          }

                                                                                                                                          type ContainsPiiEntitiesOutput

                                                                                                                                          type ContainsPiiEntitiesOutput struct {
                                                                                                                                          
                                                                                                                                          	// The labels used in the document being analyzed. Individual labels represent
                                                                                                                                          	// personally identifiable information (PII) entity types.
                                                                                                                                          	Labels []types.EntityLabel
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type CreateDocumentClassifierInput

                                                                                                                                          type CreateDocumentClassifierInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the AWS Identity and Management (IAM) role
                                                                                                                                          	// that grants Amazon Comprehend read access to your input data.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	DataAccessRoleArn *string
                                                                                                                                          
                                                                                                                                          	// The name of the document classifier.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	DocumentClassifierName *string
                                                                                                                                          
                                                                                                                                          	// Specifies the format and location of the input data for the job.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	InputDataConfig *types.DocumentClassifierInputDataConfig
                                                                                                                                          
                                                                                                                                          	// The language of the input documents. You can specify any of the following
                                                                                                                                          	// languages supported by Amazon Comprehend: German ("de"), English ("en"), Spanish
                                                                                                                                          	// ("es"), French ("fr"), Italian ("it"), or Portuguese ("pt"). All documents must
                                                                                                                                          	// be in the same language.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	LanguageCode types.LanguageCode
                                                                                                                                          
                                                                                                                                          	// A unique identifier for the request. If you don't set the client request token,
                                                                                                                                          	// Amazon Comprehend generates one.
                                                                                                                                          	ClientRequestToken *string
                                                                                                                                          
                                                                                                                                          	// Indicates the mode in which the classifier will be trained. The classifier can
                                                                                                                                          	// be trained in multi-class mode, which identifies one and only one class for each
                                                                                                                                          	// document, or multi-label mode, which identifies one or more labels for each
                                                                                                                                          	// document. In multi-label mode, multiple labels for an individual document are
                                                                                                                                          	// separated by a delimiter. The default delimiter between labels is a pipe (|).
                                                                                                                                          	Mode types.DocumentClassifierMode
                                                                                                                                          
                                                                                                                                          	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                          	// encrypt trained custom models. The ModelKmsKeyId can be either of the following
                                                                                                                                          	// formats:
                                                                                                                                          	//
                                                                                                                                          	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                          	//
                                                                                                                                          	// * Amazon
                                                                                                                                          	// Resource Name (ARN) of a KMS Key:
                                                                                                                                          	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                          	ModelKmsKeyId *string
                                                                                                                                          
                                                                                                                                          	// Enables the addition of output results configuration parameters for custom
                                                                                                                                          	// classifier jobs.
                                                                                                                                          	OutputDataConfig *types.DocumentClassifierOutputDataConfig
                                                                                                                                          
                                                                                                                                          	// Tags to be associated with the document classifier being created. A tag is a
                                                                                                                                          	// key-value pair that adds as a metadata to a resource used by Amazon Comprehend.
                                                                                                                                          	// For example, a tag with "Sales" as the key might be added to a resource to
                                                                                                                                          	// indicate its use by the sales department.
                                                                                                                                          	Tags []types.Tag
                                                                                                                                          
                                                                                                                                          	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                          	// encrypt data on the storage volume attached to the ML compute instance(s) that
                                                                                                                                          	// process the analysis job. The VolumeKmsKeyId can be either of the following
                                                                                                                                          	// formats:
                                                                                                                                          	//
                                                                                                                                          	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                          	//
                                                                                                                                          	// * Amazon
                                                                                                                                          	// Resource Name (ARN) of a KMS Key:
                                                                                                                                          	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                          	VolumeKmsKeyId *string
                                                                                                                                          
                                                                                                                                          	// Configuration parameters for an optional private Virtual Private Cloud (VPC)
                                                                                                                                          	// containing the resources you are using for your custom classifier. For more
                                                                                                                                          	// information, see Amazon VPC
                                                                                                                                          	// (https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).
                                                                                                                                          	VpcConfig *types.VpcConfig
                                                                                                                                          }

                                                                                                                                          type CreateDocumentClassifierOutput

                                                                                                                                          type CreateDocumentClassifierOutput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) that identifies the document classifier.
                                                                                                                                          	DocumentClassifierArn *string
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type CreateEndpointInput

                                                                                                                                          type CreateEndpointInput struct {
                                                                                                                                          
                                                                                                                                          	// The desired number of inference units to be used by the model using this
                                                                                                                                          	// endpoint. Each inference unit represents of a throughput of 100 characters per
                                                                                                                                          	// second.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	DesiredInferenceUnits *int32
                                                                                                                                          
                                                                                                                                          	// This is the descriptive suffix that becomes part of the EndpointArn used for all
                                                                                                                                          	// subsequent requests to this resource.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	EndpointName *string
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Number (ARN) of the model to which the endpoint will be
                                                                                                                                          	// attached.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	ModelArn *string
                                                                                                                                          
                                                                                                                                          	// An idempotency token provided by the customer. If this token matches a previous
                                                                                                                                          	// endpoint creation request, Amazon Comprehend will not return a
                                                                                                                                          	// ResourceInUseException.
                                                                                                                                          	ClientRequestToken *string
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the AWS identity and Access Management (IAM)
                                                                                                                                          	// role that grants Amazon Comprehend read access to trained custom models
                                                                                                                                          	// encrypted with a customer managed key (ModelKmsKeyId).
                                                                                                                                          	DataAccessRoleArn *string
                                                                                                                                          
                                                                                                                                          	// Tags associated with the endpoint being created. A tag is a key-value pair that
                                                                                                                                          	// adds metadata to the endpoint. For example, a tag with "Sales" as the key might
                                                                                                                                          	// be added to an endpoint to indicate its use by the sales department.
                                                                                                                                          	Tags []types.Tag
                                                                                                                                          }

                                                                                                                                          type CreateEndpointOutput

                                                                                                                                          type CreateEndpointOutput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Number (ARN) of the endpoint being created.
                                                                                                                                          	EndpointArn *string
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type CreateEntityRecognizerInput

                                                                                                                                          type CreateEntityRecognizerInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the AWS Identity and Management (IAM) role
                                                                                                                                          	// that grants Amazon Comprehend read access to your input data.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	DataAccessRoleArn *string
                                                                                                                                          
                                                                                                                                          	// Specifies the format and location of the input data. The S3 bucket containing
                                                                                                                                          	// the input data must be located in the same region as the entity recognizer being
                                                                                                                                          	// created.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	InputDataConfig *types.EntityRecognizerInputDataConfig
                                                                                                                                          
                                                                                                                                          	// You can specify any of the following languages supported by Amazon Comprehend:
                                                                                                                                          	// English ("en"), Spanish ("es"), French ("fr"), Italian ("it"), German ("de"), or
                                                                                                                                          	// Portuguese ("pt"). All documents must be in the same language.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	LanguageCode types.LanguageCode
                                                                                                                                          
                                                                                                                                          	// The name given to the newly created recognizer. Recognizer names can be a
                                                                                                                                          	// maximum of 256 characters. Alphanumeric characters, hyphens (-) and underscores
                                                                                                                                          	// (_) are allowed. The name must be unique in the account/region.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	RecognizerName *string
                                                                                                                                          
                                                                                                                                          	// A unique identifier for the request. If you don't set the client request token,
                                                                                                                                          	// Amazon Comprehend generates one.
                                                                                                                                          	ClientRequestToken *string
                                                                                                                                          
                                                                                                                                          	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                          	// encrypt trained custom models. The ModelKmsKeyId can be either of the following
                                                                                                                                          	// formats
                                                                                                                                          	//
                                                                                                                                          	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                          	//
                                                                                                                                          	// * Amazon Resource
                                                                                                                                          	// Name (ARN) of a KMS Key:
                                                                                                                                          	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                          	ModelKmsKeyId *string
                                                                                                                                          
                                                                                                                                          	// Tags to be associated with the entity recognizer being created. A tag is a
                                                                                                                                          	// key-value pair that adds as a metadata to a resource used by Amazon Comprehend.
                                                                                                                                          	// For example, a tag with "Sales" as the key might be added to a resource to
                                                                                                                                          	// indicate its use by the sales department.
                                                                                                                                          	Tags []types.Tag
                                                                                                                                          
                                                                                                                                          	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                          	// encrypt data on the storage volume attached to the ML compute instance(s) that
                                                                                                                                          	// process the analysis job. The VolumeKmsKeyId can be either of the following
                                                                                                                                          	// formats:
                                                                                                                                          	//
                                                                                                                                          	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                          	//
                                                                                                                                          	// * Amazon
                                                                                                                                          	// Resource Name (ARN) of a KMS Key:
                                                                                                                                          	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                          	VolumeKmsKeyId *string
                                                                                                                                          
                                                                                                                                          	// Configuration parameters for an optional private Virtual Private Cloud (VPC)
                                                                                                                                          	// containing the resources you are using for your custom entity recognizer. For
                                                                                                                                          	// more information, see Amazon VPC
                                                                                                                                          	// (https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).
                                                                                                                                          	VpcConfig *types.VpcConfig
                                                                                                                                          }

                                                                                                                                          type CreateEntityRecognizerOutput

                                                                                                                                          type CreateEntityRecognizerOutput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) that identifies the entity recognizer.
                                                                                                                                          	EntityRecognizerArn *string
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DeleteDocumentClassifierInput

                                                                                                                                          type DeleteDocumentClassifierInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) that identifies the document classifier.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	DocumentClassifierArn *string
                                                                                                                                          }

                                                                                                                                          type DeleteDocumentClassifierOutput

                                                                                                                                          type DeleteDocumentClassifierOutput struct {
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DeleteEndpointInput

                                                                                                                                          type DeleteEndpointInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Number (ARN) of the endpoint being deleted.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	EndpointArn *string
                                                                                                                                          }

                                                                                                                                          type DeleteEndpointOutput

                                                                                                                                          type DeleteEndpointOutput struct {
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DeleteEntityRecognizerInput

                                                                                                                                          type DeleteEntityRecognizerInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) that identifies the entity recognizer.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	EntityRecognizerArn *string
                                                                                                                                          }

                                                                                                                                          type DeleteEntityRecognizerOutput

                                                                                                                                          type DeleteEntityRecognizerOutput struct {
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeDocumentClassificationJobInput

                                                                                                                                          type DescribeDocumentClassificationJobInput struct {
                                                                                                                                          
                                                                                                                                          	// The identifier that Amazon Comprehend generated for the job. The operation
                                                                                                                                          	// returns this identifier in its response.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	JobId *string
                                                                                                                                          }

                                                                                                                                          type DescribeDocumentClassificationJobOutput

                                                                                                                                          type DescribeDocumentClassificationJobOutput struct {
                                                                                                                                          
                                                                                                                                          	// An object that describes the properties associated with the document
                                                                                                                                          	// classification job.
                                                                                                                                          	DocumentClassificationJobProperties *types.DocumentClassificationJobProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeDocumentClassifierInput

                                                                                                                                          type DescribeDocumentClassifierInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) that identifies the document classifier. The
                                                                                                                                          	// operation returns this identifier in its response.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	DocumentClassifierArn *string
                                                                                                                                          }

                                                                                                                                          type DescribeDocumentClassifierOutput

                                                                                                                                          type DescribeDocumentClassifierOutput struct {
                                                                                                                                          
                                                                                                                                          	// An object that contains the properties associated with a document classifier.
                                                                                                                                          	DocumentClassifierProperties *types.DocumentClassifierProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeDominantLanguageDetectionJobInput

                                                                                                                                          type DescribeDominantLanguageDetectionJobInput struct {
                                                                                                                                          
                                                                                                                                          	// The identifier that Amazon Comprehend generated for the job. The operation
                                                                                                                                          	// returns this identifier in its response.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	JobId *string
                                                                                                                                          }

                                                                                                                                          type DescribeDominantLanguageDetectionJobOutput

                                                                                                                                          type DescribeDominantLanguageDetectionJobOutput struct {
                                                                                                                                          
                                                                                                                                          	// An object that contains the properties associated with a dominant language
                                                                                                                                          	// detection job.
                                                                                                                                          	DominantLanguageDetectionJobProperties *types.DominantLanguageDetectionJobProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeEndpointInput

                                                                                                                                          type DescribeEndpointInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Number (ARN) of the endpoint being described.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	EndpointArn *string
                                                                                                                                          }

                                                                                                                                          type DescribeEndpointOutput

                                                                                                                                          type DescribeEndpointOutput struct {
                                                                                                                                          
                                                                                                                                          	// Describes information associated with the specific endpoint.
                                                                                                                                          	EndpointProperties *types.EndpointProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeEntitiesDetectionJobInput

                                                                                                                                          type DescribeEntitiesDetectionJobInput struct {
                                                                                                                                          
                                                                                                                                          	// The identifier that Amazon Comprehend generated for the job. The operation
                                                                                                                                          	// returns this identifier in its response.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	JobId *string
                                                                                                                                          }

                                                                                                                                          type DescribeEntitiesDetectionJobOutput

                                                                                                                                          type DescribeEntitiesDetectionJobOutput struct {
                                                                                                                                          
                                                                                                                                          	// An object that contains the properties associated with an entities detection
                                                                                                                                          	// job.
                                                                                                                                          	EntitiesDetectionJobProperties *types.EntitiesDetectionJobProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeEntityRecognizerInput

                                                                                                                                          type DescribeEntityRecognizerInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) that identifies the entity recognizer.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	EntityRecognizerArn *string
                                                                                                                                          }

                                                                                                                                          type DescribeEntityRecognizerOutput

                                                                                                                                          type DescribeEntityRecognizerOutput struct {
                                                                                                                                          
                                                                                                                                          	// Describes information associated with an entity recognizer.
                                                                                                                                          	EntityRecognizerProperties *types.EntityRecognizerProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeEventsDetectionJobInput

                                                                                                                                          type DescribeEventsDetectionJobInput struct {
                                                                                                                                          
                                                                                                                                          	// The identifier of the events detection job.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	JobId *string
                                                                                                                                          }

                                                                                                                                          type DescribeEventsDetectionJobOutput

                                                                                                                                          type DescribeEventsDetectionJobOutput struct {
                                                                                                                                          
                                                                                                                                          	// An object that contains the properties associated with an event detection job.
                                                                                                                                          	EventsDetectionJobProperties *types.EventsDetectionJobProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeKeyPhrasesDetectionJobInput

                                                                                                                                          type DescribeKeyPhrasesDetectionJobInput struct {
                                                                                                                                          
                                                                                                                                          	// The identifier that Amazon Comprehend generated for the job. The operation
                                                                                                                                          	// returns this identifier in its response.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	JobId *string
                                                                                                                                          }

                                                                                                                                          type DescribeKeyPhrasesDetectionJobOutput

                                                                                                                                          type DescribeKeyPhrasesDetectionJobOutput struct {
                                                                                                                                          
                                                                                                                                          	// An object that contains the properties associated with a key phrases detection
                                                                                                                                          	// job.
                                                                                                                                          	KeyPhrasesDetectionJobProperties *types.KeyPhrasesDetectionJobProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribePiiEntitiesDetectionJobInput

                                                                                                                                          type DescribePiiEntitiesDetectionJobInput struct {
                                                                                                                                          
                                                                                                                                          	// The identifier that Amazon Comprehend generated for the job. The operation
                                                                                                                                          	// returns this identifier in its response.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	JobId *string
                                                                                                                                          }

                                                                                                                                          type DescribePiiEntitiesDetectionJobOutput

                                                                                                                                          type DescribePiiEntitiesDetectionJobOutput struct {
                                                                                                                                          
                                                                                                                                          	// Provides information about a PII entities detection job.
                                                                                                                                          	PiiEntitiesDetectionJobProperties *types.PiiEntitiesDetectionJobProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeSentimentDetectionJobInput

                                                                                                                                          type DescribeSentimentDetectionJobInput struct {
                                                                                                                                          
                                                                                                                                          	// The identifier that Amazon Comprehend generated for the job. The operation
                                                                                                                                          	// returns this identifier in its response.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	JobId *string
                                                                                                                                          }

                                                                                                                                          type DescribeSentimentDetectionJobOutput

                                                                                                                                          type DescribeSentimentDetectionJobOutput struct {
                                                                                                                                          
                                                                                                                                          	// An object that contains the properties associated with a sentiment detection
                                                                                                                                          	// job.
                                                                                                                                          	SentimentDetectionJobProperties *types.SentimentDetectionJobProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DescribeTopicsDetectionJobInput

                                                                                                                                          type DescribeTopicsDetectionJobInput struct {
                                                                                                                                          
                                                                                                                                          	// The identifier assigned by the user to the detection job.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	JobId *string
                                                                                                                                          }

                                                                                                                                          type DescribeTopicsDetectionJobOutput

                                                                                                                                          type DescribeTopicsDetectionJobOutput struct {
                                                                                                                                          
                                                                                                                                          	// The list of properties for the requested job.
                                                                                                                                          	TopicsDetectionJobProperties *types.TopicsDetectionJobProperties
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DetectDominantLanguageInput

                                                                                                                                          type DetectDominantLanguageInput struct {
                                                                                                                                          
                                                                                                                                          	// A UTF-8 text string. Each string should contain at least 20 characters and must
                                                                                                                                          	// contain fewer that 5,000 bytes of UTF-8 encoded characters.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Text *string
                                                                                                                                          }

                                                                                                                                          type DetectDominantLanguageOutput

                                                                                                                                          type DetectDominantLanguageOutput struct {
                                                                                                                                          
                                                                                                                                          	// The languages that Amazon Comprehend detected in the input text. For each
                                                                                                                                          	// language, the response returns the RFC 5646 language code and the level of
                                                                                                                                          	// confidence that Amazon Comprehend has in the accuracy of its inference. For more
                                                                                                                                          	// information about RFC 5646, see Tags for Identifying Languages
                                                                                                                                          	// (https://tools.ietf.org/html/rfc5646) on the IETF Tools web site.
                                                                                                                                          	Languages []types.DominantLanguage
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DetectEntitiesInput

                                                                                                                                          type DetectEntitiesInput struct {
                                                                                                                                          
                                                                                                                                          	// A UTF-8 text string. Each string must contain fewer that 5,000 bytes of UTF-8
                                                                                                                                          	// encoded characters.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Text *string
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name of an endpoint that is associated with a custom entity
                                                                                                                                          	// recognition model. Provide an endpoint if you want to detect entities by using
                                                                                                                                          	// your own custom model instead of the default model that is used by Amazon
                                                                                                                                          	// Comprehend. If you specify an endpoint, Amazon Comprehend uses the language of
                                                                                                                                          	// your custom model, and it ignores any language code that you provide in your
                                                                                                                                          	// request.
                                                                                                                                          	EndpointArn *string
                                                                                                                                          
                                                                                                                                          	// The language of the input documents. You can specify any of the primary
                                                                                                                                          	// languages supported by Amazon Comprehend. All documents must be in the same
                                                                                                                                          	// language. If your request includes the endpoint for a custom entity recognition
                                                                                                                                          	// model, Amazon Comprehend uses the language of your custom model, and it ignores
                                                                                                                                          	// any language code that you specify here.
                                                                                                                                          	LanguageCode types.LanguageCode
                                                                                                                                          }

                                                                                                                                          type DetectEntitiesOutput

                                                                                                                                          type DetectEntitiesOutput struct {
                                                                                                                                          
                                                                                                                                          	// A collection of entities identified in the input text. For each entity, the
                                                                                                                                          	// response provides the entity text, entity type, where the entity text begins and
                                                                                                                                          	// ends, and the level of confidence that Amazon Comprehend has in the detection.
                                                                                                                                          	// If your request uses a custom entity recognition model, Amazon Comprehend
                                                                                                                                          	// detects the entities that the model is trained to recognize. Otherwise, it
                                                                                                                                          	// detects the default entity types. For a list of default entity types, see
                                                                                                                                          	// how-entities.
                                                                                                                                          	Entities []types.Entity
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DetectKeyPhrasesInput

                                                                                                                                          type DetectKeyPhrasesInput struct {
                                                                                                                                          
                                                                                                                                          	// The language of the input documents. You can specify any of the primary
                                                                                                                                          	// languages supported by Amazon Comprehend. All documents must be in the same
                                                                                                                                          	// language.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	LanguageCode types.LanguageCode
                                                                                                                                          
                                                                                                                                          	// A UTF-8 text string. Each string must contain fewer that 5,000 bytes of UTF-8
                                                                                                                                          	// encoded characters.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Text *string
                                                                                                                                          }

                                                                                                                                          type DetectKeyPhrasesOutput

                                                                                                                                          type DetectKeyPhrasesOutput struct {
                                                                                                                                          
                                                                                                                                          	// A collection of key phrases that Amazon Comprehend identified in the input text.
                                                                                                                                          	// For each key phrase, the response provides the text of the key phrase, where the
                                                                                                                                          	// key phrase begins and ends, and the level of confidence that Amazon Comprehend
                                                                                                                                          	// has in the accuracy of the detection.
                                                                                                                                          	KeyPhrases []types.KeyPhrase
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DetectPiiEntitiesInput

                                                                                                                                          type DetectPiiEntitiesInput struct {
                                                                                                                                          
                                                                                                                                          	// The language of the input documents.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	LanguageCode types.LanguageCode
                                                                                                                                          
                                                                                                                                          	// A UTF-8 text string. Each string must contain fewer that 5,000 bytes of UTF-8
                                                                                                                                          	// encoded characters.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Text *string
                                                                                                                                          }

                                                                                                                                          type DetectPiiEntitiesOutput

                                                                                                                                          type DetectPiiEntitiesOutput struct {
                                                                                                                                          
                                                                                                                                          	// A collection of PII entities identified in the input text. For each entity, the
                                                                                                                                          	// response provides the entity type, where the entity text begins and ends, and
                                                                                                                                          	// the level of confidence that Amazon Comprehend has in the detection.
                                                                                                                                          	Entities []types.PiiEntity
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DetectSentimentInput

                                                                                                                                          type DetectSentimentInput struct {
                                                                                                                                          
                                                                                                                                          	// The language of the input documents. You can specify any of the primary
                                                                                                                                          	// languages supported by Amazon Comprehend. All documents must be in the same
                                                                                                                                          	// language.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	LanguageCode types.LanguageCode
                                                                                                                                          
                                                                                                                                          	// A UTF-8 text string. Each string must contain fewer that 5,000 bytes of UTF-8
                                                                                                                                          	// encoded characters.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Text *string
                                                                                                                                          }

                                                                                                                                          type DetectSentimentOutput

                                                                                                                                          type DetectSentimentOutput struct {
                                                                                                                                          
                                                                                                                                          	// The inferred sentiment that Amazon Comprehend has the highest level of
                                                                                                                                          	// confidence in.
                                                                                                                                          	Sentiment types.SentimentType
                                                                                                                                          
                                                                                                                                          	// An object that lists the sentiments, and their corresponding confidence levels.
                                                                                                                                          	SentimentScore *types.SentimentScore
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type DetectSyntaxInput

                                                                                                                                          type DetectSyntaxInput struct {
                                                                                                                                          
                                                                                                                                          	// The language code of the input documents. You can specify any of the following
                                                                                                                                          	// languages supported by Amazon Comprehend: German ("de"), English ("en"), Spanish
                                                                                                                                          	// ("es"), French ("fr"), Italian ("it"), or Portuguese ("pt").
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	LanguageCode types.SyntaxLanguageCode
                                                                                                                                          
                                                                                                                                          	// A UTF-8 string. Each string must contain fewer that 5,000 bytes of UTF encoded
                                                                                                                                          	// characters.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Text *string
                                                                                                                                          }

                                                                                                                                          type DetectSyntaxOutput

                                                                                                                                          type DetectSyntaxOutput struct {
                                                                                                                                          
                                                                                                                                          	// A collection of syntax tokens describing the text. For each token, the response
                                                                                                                                          	// provides the text, the token type, where the text begins and ends, and the level
                                                                                                                                          	// of confidence that Amazon Comprehend has that the token is correct. For a list
                                                                                                                                          	// of token types, see how-syntax.
                                                                                                                                          	SyntaxTokens []types.SyntaxToken
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type EndpointResolver

                                                                                                                                          type EndpointResolver interface {
                                                                                                                                          	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                                                                                          }

                                                                                                                                            EndpointResolver interface for resolving service endpoints.

                                                                                                                                            func EndpointResolverFromURL

                                                                                                                                            func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                                                                              EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                                                                              type EndpointResolverFunc

                                                                                                                                              type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                                                                                                EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                                                                                func (EndpointResolverFunc) ResolveEndpoint

                                                                                                                                                func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                                                                                type EndpointResolverOptions

                                                                                                                                                type EndpointResolverOptions = internalendpoints.Options

                                                                                                                                                  EndpointResolverOptions is the service endpoint resolver options

                                                                                                                                                  type HTTPClient

                                                                                                                                                  type HTTPClient interface {
                                                                                                                                                  	Do(*http.Request) (*http.Response, error)
                                                                                                                                                  }

                                                                                                                                                  type HTTPSignerV4

                                                                                                                                                  type HTTPSignerV4 interface {
                                                                                                                                                  	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                                                                                  }

                                                                                                                                                  type IdempotencyTokenProvider

                                                                                                                                                  type IdempotencyTokenProvider interface {
                                                                                                                                                  	GetIdempotencyToken() (string, error)
                                                                                                                                                  }

                                                                                                                                                    IdempotencyTokenProvider interface for providing idempotency token

                                                                                                                                                    type ListDocumentClassificationJobsAPIClient

                                                                                                                                                    type ListDocumentClassificationJobsAPIClient interface {
                                                                                                                                                    	ListDocumentClassificationJobs(context.Context, *ListDocumentClassificationJobsInput, ...func(*Options)) (*ListDocumentClassificationJobsOutput, error)
                                                                                                                                                    }

                                                                                                                                                      ListDocumentClassificationJobsAPIClient is a client that implements the ListDocumentClassificationJobs operation.

                                                                                                                                                      type ListDocumentClassificationJobsInput

                                                                                                                                                      type ListDocumentClassificationJobsInput struct {
                                                                                                                                                      
                                                                                                                                                      	// Filters the jobs that are returned. You can filter jobs on their names, status,
                                                                                                                                                      	// or the date and time that they were submitted. You can only set one filter at a
                                                                                                                                                      	// time.
                                                                                                                                                      	Filter *types.DocumentClassificationJobFilter
                                                                                                                                                      
                                                                                                                                                      	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                      	MaxResults *int32
                                                                                                                                                      
                                                                                                                                                      	// Identifies the next page of results to return.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      }

                                                                                                                                                      type ListDocumentClassificationJobsOutput

                                                                                                                                                      type ListDocumentClassificationJobsOutput struct {
                                                                                                                                                      
                                                                                                                                                      	// A list containing the properties of each job returned.
                                                                                                                                                      	DocumentClassificationJobPropertiesList []types.DocumentClassificationJobProperties
                                                                                                                                                      
                                                                                                                                                      	// Identifies the next page of results to return.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      
                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                      }

                                                                                                                                                      type ListDocumentClassificationJobsPaginator

                                                                                                                                                      type ListDocumentClassificationJobsPaginator struct {
                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                      }

                                                                                                                                                        ListDocumentClassificationJobsPaginator is a paginator for ListDocumentClassificationJobs

                                                                                                                                                        func NewListDocumentClassificationJobsPaginator

                                                                                                                                                          NewListDocumentClassificationJobsPaginator returns a new ListDocumentClassificationJobsPaginator

                                                                                                                                                          func (*ListDocumentClassificationJobsPaginator) HasMorePages

                                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                            func (*ListDocumentClassificationJobsPaginator) NextPage

                                                                                                                                                              NextPage retrieves the next ListDocumentClassificationJobs page.

                                                                                                                                                              type ListDocumentClassificationJobsPaginatorOptions

                                                                                                                                                              type ListDocumentClassificationJobsPaginatorOptions struct {
                                                                                                                                                              	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                              	Limit int32
                                                                                                                                                              
                                                                                                                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                              	// that matches the most recent token provided to the service.
                                                                                                                                                              	StopOnDuplicateToken bool
                                                                                                                                                              }

                                                                                                                                                                ListDocumentClassificationJobsPaginatorOptions is the paginator options for ListDocumentClassificationJobs

                                                                                                                                                                type ListDocumentClassifiersAPIClient

                                                                                                                                                                type ListDocumentClassifiersAPIClient interface {
                                                                                                                                                                	ListDocumentClassifiers(context.Context, *ListDocumentClassifiersInput, ...func(*Options)) (*ListDocumentClassifiersOutput, error)
                                                                                                                                                                }

                                                                                                                                                                  ListDocumentClassifiersAPIClient is a client that implements the ListDocumentClassifiers operation.

                                                                                                                                                                  type ListDocumentClassifiersInput

                                                                                                                                                                  type ListDocumentClassifiersInput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// Filters the jobs that are returned. You can filter jobs on their name, status,
                                                                                                                                                                  	// or the date and time that they were submitted. You can only set one filter at a
                                                                                                                                                                  	// time.
                                                                                                                                                                  	Filter *types.DocumentClassifierFilter
                                                                                                                                                                  
                                                                                                                                                                  	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                  	MaxResults *int32
                                                                                                                                                                  
                                                                                                                                                                  	// Identifies the next page of results to return.
                                                                                                                                                                  	NextToken *string
                                                                                                                                                                  }

                                                                                                                                                                  type ListDocumentClassifiersOutput

                                                                                                                                                                  type ListDocumentClassifiersOutput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// A list containing the properties of each job returned.
                                                                                                                                                                  	DocumentClassifierPropertiesList []types.DocumentClassifierProperties
                                                                                                                                                                  
                                                                                                                                                                  	// Identifies the next page of results to return.
                                                                                                                                                                  	NextToken *string
                                                                                                                                                                  
                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                  }

                                                                                                                                                                  type ListDocumentClassifiersPaginator

                                                                                                                                                                  type ListDocumentClassifiersPaginator struct {
                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                  }

                                                                                                                                                                    ListDocumentClassifiersPaginator is a paginator for ListDocumentClassifiers

                                                                                                                                                                    func NewListDocumentClassifiersPaginator

                                                                                                                                                                      NewListDocumentClassifiersPaginator returns a new ListDocumentClassifiersPaginator

                                                                                                                                                                      func (*ListDocumentClassifiersPaginator) HasMorePages

                                                                                                                                                                      func (p *ListDocumentClassifiersPaginator) HasMorePages() bool

                                                                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                        func (*ListDocumentClassifiersPaginator) NextPage

                                                                                                                                                                          NextPage retrieves the next ListDocumentClassifiers page.

                                                                                                                                                                          type ListDocumentClassifiersPaginatorOptions

                                                                                                                                                                          type ListDocumentClassifiersPaginatorOptions struct {
                                                                                                                                                                          	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                          	Limit int32
                                                                                                                                                                          
                                                                                                                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                          	// that matches the most recent token provided to the service.
                                                                                                                                                                          	StopOnDuplicateToken bool
                                                                                                                                                                          }

                                                                                                                                                                            ListDocumentClassifiersPaginatorOptions is the paginator options for ListDocumentClassifiers

                                                                                                                                                                            type ListDominantLanguageDetectionJobsAPIClient

                                                                                                                                                                            type ListDominantLanguageDetectionJobsAPIClient interface {
                                                                                                                                                                            	ListDominantLanguageDetectionJobs(context.Context, *ListDominantLanguageDetectionJobsInput, ...func(*Options)) (*ListDominantLanguageDetectionJobsOutput, error)
                                                                                                                                                                            }

                                                                                                                                                                              ListDominantLanguageDetectionJobsAPIClient is a client that implements the ListDominantLanguageDetectionJobs operation.

                                                                                                                                                                              type ListDominantLanguageDetectionJobsInput

                                                                                                                                                                              type ListDominantLanguageDetectionJobsInput struct {
                                                                                                                                                                              
                                                                                                                                                                              	// Filters that jobs that are returned. You can filter jobs on their name, status,
                                                                                                                                                                              	// or the date and time that they were submitted. You can only set one filter at a
                                                                                                                                                                              	// time.
                                                                                                                                                                              	Filter *types.DominantLanguageDetectionJobFilter
                                                                                                                                                                              
                                                                                                                                                                              	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                              	MaxResults *int32
                                                                                                                                                                              
                                                                                                                                                                              	// Identifies the next page of results to return.
                                                                                                                                                                              	NextToken *string
                                                                                                                                                                              }

                                                                                                                                                                              type ListDominantLanguageDetectionJobsOutput

                                                                                                                                                                              type ListDominantLanguageDetectionJobsOutput struct {
                                                                                                                                                                              
                                                                                                                                                                              	// A list containing the properties of each job that is returned.
                                                                                                                                                                              	DominantLanguageDetectionJobPropertiesList []types.DominantLanguageDetectionJobProperties
                                                                                                                                                                              
                                                                                                                                                                              	// Identifies the next page of results to return.
                                                                                                                                                                              	NextToken *string
                                                                                                                                                                              
                                                                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                                                                              }

                                                                                                                                                                              type ListDominantLanguageDetectionJobsPaginator

                                                                                                                                                                              type ListDominantLanguageDetectionJobsPaginator struct {
                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                              }

                                                                                                                                                                                ListDominantLanguageDetectionJobsPaginator is a paginator for ListDominantLanguageDetectionJobs

                                                                                                                                                                                func NewListDominantLanguageDetectionJobsPaginator

                                                                                                                                                                                  NewListDominantLanguageDetectionJobsPaginator returns a new ListDominantLanguageDetectionJobsPaginator

                                                                                                                                                                                  func (*ListDominantLanguageDetectionJobsPaginator) HasMorePages

                                                                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                    func (*ListDominantLanguageDetectionJobsPaginator) NextPage

                                                                                                                                                                                      NextPage retrieves the next ListDominantLanguageDetectionJobs page.

                                                                                                                                                                                      type ListDominantLanguageDetectionJobsPaginatorOptions

                                                                                                                                                                                      type ListDominantLanguageDetectionJobsPaginatorOptions struct {
                                                                                                                                                                                      	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                      	Limit int32
                                                                                                                                                                                      
                                                                                                                                                                                      	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                      	// that matches the most recent token provided to the service.
                                                                                                                                                                                      	StopOnDuplicateToken bool
                                                                                                                                                                                      }

                                                                                                                                                                                        ListDominantLanguageDetectionJobsPaginatorOptions is the paginator options for ListDominantLanguageDetectionJobs

                                                                                                                                                                                        type ListEndpointsInput

                                                                                                                                                                                        type ListEndpointsInput struct {
                                                                                                                                                                                        
                                                                                                                                                                                        	// Filters the endpoints that are returned. You can filter endpoints on their name,
                                                                                                                                                                                        	// model, status, or the date and time that they were created. You can only set one
                                                                                                                                                                                        	// filter at a time.
                                                                                                                                                                                        	Filter *types.EndpointFilter
                                                                                                                                                                                        
                                                                                                                                                                                        	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                        	MaxResults *int32
                                                                                                                                                                                        
                                                                                                                                                                                        	// Identifies the next page of results to return.
                                                                                                                                                                                        	NextToken *string
                                                                                                                                                                                        }

                                                                                                                                                                                        type ListEndpointsOutput

                                                                                                                                                                                        type ListEndpointsOutput struct {
                                                                                                                                                                                        
                                                                                                                                                                                        	// Displays a list of endpoint properties being retrieved by the service in
                                                                                                                                                                                        	// response to the request.
                                                                                                                                                                                        	EndpointPropertiesList []types.EndpointProperties
                                                                                                                                                                                        
                                                                                                                                                                                        	// Identifies the next page of results to return.
                                                                                                                                                                                        	NextToken *string
                                                                                                                                                                                        
                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                        }

                                                                                                                                                                                        type ListEntitiesDetectionJobsAPIClient

                                                                                                                                                                                        type ListEntitiesDetectionJobsAPIClient interface {
                                                                                                                                                                                        	ListEntitiesDetectionJobs(context.Context, *ListEntitiesDetectionJobsInput, ...func(*Options)) (*ListEntitiesDetectionJobsOutput, error)
                                                                                                                                                                                        }

                                                                                                                                                                                          ListEntitiesDetectionJobsAPIClient is a client that implements the ListEntitiesDetectionJobs operation.

                                                                                                                                                                                          type ListEntitiesDetectionJobsInput

                                                                                                                                                                                          type ListEntitiesDetectionJobsInput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// Filters the jobs that are returned. You can filter jobs on their name, status,
                                                                                                                                                                                          	// or the date and time that they were submitted. You can only set one filter at a
                                                                                                                                                                                          	// time.
                                                                                                                                                                                          	Filter *types.EntitiesDetectionJobFilter
                                                                                                                                                                                          
                                                                                                                                                                                          	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                          	MaxResults *int32
                                                                                                                                                                                          
                                                                                                                                                                                          	// Identifies the next page of results to return.
                                                                                                                                                                                          	NextToken *string
                                                                                                                                                                                          }

                                                                                                                                                                                          type ListEntitiesDetectionJobsOutput

                                                                                                                                                                                          type ListEntitiesDetectionJobsOutput struct {
                                                                                                                                                                                          
                                                                                                                                                                                          	// A list containing the properties of each job that is returned.
                                                                                                                                                                                          	EntitiesDetectionJobPropertiesList []types.EntitiesDetectionJobProperties
                                                                                                                                                                                          
                                                                                                                                                                                          	// Identifies the next page of results to return.
                                                                                                                                                                                          	NextToken *string
                                                                                                                                                                                          
                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                          }

                                                                                                                                                                                          type ListEntitiesDetectionJobsPaginator

                                                                                                                                                                                          type ListEntitiesDetectionJobsPaginator struct {
                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                          }

                                                                                                                                                                                            ListEntitiesDetectionJobsPaginator is a paginator for ListEntitiesDetectionJobs

                                                                                                                                                                                            func NewListEntitiesDetectionJobsPaginator

                                                                                                                                                                                              NewListEntitiesDetectionJobsPaginator returns a new ListEntitiesDetectionJobsPaginator

                                                                                                                                                                                              func (*ListEntitiesDetectionJobsPaginator) HasMorePages

                                                                                                                                                                                              func (p *ListEntitiesDetectionJobsPaginator) HasMorePages() bool

                                                                                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                func (*ListEntitiesDetectionJobsPaginator) NextPage

                                                                                                                                                                                                  NextPage retrieves the next ListEntitiesDetectionJobs page.

                                                                                                                                                                                                  type ListEntitiesDetectionJobsPaginatorOptions

                                                                                                                                                                                                  type ListEntitiesDetectionJobsPaginatorOptions struct {
                                                                                                                                                                                                  	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                                  	Limit int32
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                  	// that matches the most recent token provided to the service.
                                                                                                                                                                                                  	StopOnDuplicateToken bool
                                                                                                                                                                                                  }

                                                                                                                                                                                                    ListEntitiesDetectionJobsPaginatorOptions is the paginator options for ListEntitiesDetectionJobs

                                                                                                                                                                                                    type ListEntityRecognizersAPIClient

                                                                                                                                                                                                    type ListEntityRecognizersAPIClient interface {
                                                                                                                                                                                                    	ListEntityRecognizers(context.Context, *ListEntityRecognizersInput, ...func(*Options)) (*ListEntityRecognizersOutput, error)
                                                                                                                                                                                                    }

                                                                                                                                                                                                      ListEntityRecognizersAPIClient is a client that implements the ListEntityRecognizers operation.

                                                                                                                                                                                                      type ListEntityRecognizersInput

                                                                                                                                                                                                      type ListEntityRecognizersInput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Filters the list of entities returned. You can filter on Status,
                                                                                                                                                                                                      	// SubmitTimeBefore, or SubmitTimeAfter. You can only set one filter at a time.
                                                                                                                                                                                                      	Filter *types.EntityRecognizerFilter
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The maximum number of results to return on each page. The default is 100.
                                                                                                                                                                                                      	MaxResults *int32
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Identifies the next page of results to return.
                                                                                                                                                                                                      	NextToken *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type ListEntityRecognizersOutput

                                                                                                                                                                                                      type ListEntityRecognizersOutput struct {
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// The list of properties of an entity recognizer.
                                                                                                                                                                                                      	EntityRecognizerPropertiesList []types.EntityRecognizerProperties
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Identifies the next page of results to return.
                                                                                                                                                                                                      	NextToken *string
                                                                                                                                                                                                      
                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type ListEntityRecognizersPaginator

                                                                                                                                                                                                      type ListEntityRecognizersPaginator struct {
                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                      }

                                                                                                                                                                                                        ListEntityRecognizersPaginator is a paginator for ListEntityRecognizers

                                                                                                                                                                                                        func NewListEntityRecognizersPaginator

                                                                                                                                                                                                          NewListEntityRecognizersPaginator returns a new ListEntityRecognizersPaginator

                                                                                                                                                                                                          func (*ListEntityRecognizersPaginator) HasMorePages

                                                                                                                                                                                                          func (p *ListEntityRecognizersPaginator) HasMorePages() bool

                                                                                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                            func (*ListEntityRecognizersPaginator) NextPage

                                                                                                                                                                                                              NextPage retrieves the next ListEntityRecognizers page.

                                                                                                                                                                                                              type ListEntityRecognizersPaginatorOptions

                                                                                                                                                                                                              type ListEntityRecognizersPaginatorOptions struct {
                                                                                                                                                                                                              	// The maximum number of results to return on each page. The default is 100.
                                                                                                                                                                                                              	Limit int32
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                              	// that matches the most recent token provided to the service.
                                                                                                                                                                                                              	StopOnDuplicateToken bool
                                                                                                                                                                                                              }

                                                                                                                                                                                                                ListEntityRecognizersPaginatorOptions is the paginator options for ListEntityRecognizers

                                                                                                                                                                                                                type ListEventsDetectionJobsAPIClient

                                                                                                                                                                                                                type ListEventsDetectionJobsAPIClient interface {
                                                                                                                                                                                                                	ListEventsDetectionJobs(context.Context, *ListEventsDetectionJobsInput, ...func(*Options)) (*ListEventsDetectionJobsOutput, error)
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  ListEventsDetectionJobsAPIClient is a client that implements the ListEventsDetectionJobs operation.

                                                                                                                                                                                                                  type ListEventsDetectionJobsInput

                                                                                                                                                                                                                  type ListEventsDetectionJobsInput struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Filters the jobs that are returned. You can filter jobs on their name, status,
                                                                                                                                                                                                                  	// or the date and time that they were submitted. You can only set one filter at a
                                                                                                                                                                                                                  	// time.
                                                                                                                                                                                                                  	Filter *types.EventsDetectionJobFilter
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The maximum number of results to return in each page.
                                                                                                                                                                                                                  	MaxResults *int32
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Identifies the next page of results to return.
                                                                                                                                                                                                                  	NextToken *string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                  type ListEventsDetectionJobsOutput

                                                                                                                                                                                                                  type ListEventsDetectionJobsOutput struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// A list containing the properties of each job that is returned.
                                                                                                                                                                                                                  	EventsDetectionJobPropertiesList []types.EventsDetectionJobProperties
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Identifies the next page of results to return.
                                                                                                                                                                                                                  	NextToken *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                  type ListEventsDetectionJobsPaginator

                                                                                                                                                                                                                  type ListEventsDetectionJobsPaginator struct {
                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    ListEventsDetectionJobsPaginator is a paginator for ListEventsDetectionJobs

                                                                                                                                                                                                                    func NewListEventsDetectionJobsPaginator

                                                                                                                                                                                                                      NewListEventsDetectionJobsPaginator returns a new ListEventsDetectionJobsPaginator

                                                                                                                                                                                                                      func (*ListEventsDetectionJobsPaginator) HasMorePages

                                                                                                                                                                                                                      func (p *ListEventsDetectionJobsPaginator) HasMorePages() bool

                                                                                                                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                                        func (*ListEventsDetectionJobsPaginator) NextPage

                                                                                                                                                                                                                          NextPage retrieves the next ListEventsDetectionJobs page.

                                                                                                                                                                                                                          type ListEventsDetectionJobsPaginatorOptions

                                                                                                                                                                                                                          type ListEventsDetectionJobsPaginatorOptions struct {
                                                                                                                                                                                                                          	// The maximum number of results to return in each page.
                                                                                                                                                                                                                          	Limit int32
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                                          	// that matches the most recent token provided to the service.
                                                                                                                                                                                                                          	StopOnDuplicateToken bool
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            ListEventsDetectionJobsPaginatorOptions is the paginator options for ListEventsDetectionJobs

                                                                                                                                                                                                                            type ListKeyPhrasesDetectionJobsAPIClient

                                                                                                                                                                                                                            type ListKeyPhrasesDetectionJobsAPIClient interface {
                                                                                                                                                                                                                            	ListKeyPhrasesDetectionJobs(context.Context, *ListKeyPhrasesDetectionJobsInput, ...func(*Options)) (*ListKeyPhrasesDetectionJobsOutput, error)
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              ListKeyPhrasesDetectionJobsAPIClient is a client that implements the ListKeyPhrasesDetectionJobs operation.

                                                                                                                                                                                                                              type ListKeyPhrasesDetectionJobsInput

                                                                                                                                                                                                                              type ListKeyPhrasesDetectionJobsInput struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// Filters the jobs that are returned. You can filter jobs on their name, status,
                                                                                                                                                                                                                              	// or the date and time that they were submitted. You can only set one filter at a
                                                                                                                                                                                                                              	// time.
                                                                                                                                                                                                                              	Filter *types.KeyPhrasesDetectionJobFilter
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                                                              	MaxResults *int32
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// Identifies the next page of results to return.
                                                                                                                                                                                                                              	NextToken *string
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                              type ListKeyPhrasesDetectionJobsOutput

                                                                                                                                                                                                                              type ListKeyPhrasesDetectionJobsOutput struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// A list containing the properties of each job that is returned.
                                                                                                                                                                                                                              	KeyPhrasesDetectionJobPropertiesList []types.KeyPhrasesDetectionJobProperties
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// Identifies the next page of results to return.
                                                                                                                                                                                                                              	NextToken *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                              type ListKeyPhrasesDetectionJobsPaginator

                                                                                                                                                                                                                              type ListKeyPhrasesDetectionJobsPaginator struct {
                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                ListKeyPhrasesDetectionJobsPaginator is a paginator for ListKeyPhrasesDetectionJobs

                                                                                                                                                                                                                                func NewListKeyPhrasesDetectionJobsPaginator

                                                                                                                                                                                                                                  NewListKeyPhrasesDetectionJobsPaginator returns a new ListKeyPhrasesDetectionJobsPaginator

                                                                                                                                                                                                                                  func (*ListKeyPhrasesDetectionJobsPaginator) HasMorePages

                                                                                                                                                                                                                                  func (p *ListKeyPhrasesDetectionJobsPaginator) HasMorePages() bool

                                                                                                                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                                                    func (*ListKeyPhrasesDetectionJobsPaginator) NextPage

                                                                                                                                                                                                                                      NextPage retrieves the next ListKeyPhrasesDetectionJobs page.

                                                                                                                                                                                                                                      type ListKeyPhrasesDetectionJobsPaginatorOptions

                                                                                                                                                                                                                                      type ListKeyPhrasesDetectionJobsPaginatorOptions struct {
                                                                                                                                                                                                                                      	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                                                                      	Limit int32
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                                                      	// that matches the most recent token provided to the service.
                                                                                                                                                                                                                                      	StopOnDuplicateToken bool
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        ListKeyPhrasesDetectionJobsPaginatorOptions is the paginator options for ListKeyPhrasesDetectionJobs

                                                                                                                                                                                                                                        type ListPiiEntitiesDetectionJobsInput

                                                                                                                                                                                                                                        type ListPiiEntitiesDetectionJobsInput struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Filters the jobs that are returned. You can filter jobs on their name, status,
                                                                                                                                                                                                                                        	// or the date and time that they were submitted. You can only set one filter at a
                                                                                                                                                                                                                                        	// time.
                                                                                                                                                                                                                                        	Filter *types.PiiEntitiesDetectionJobFilter
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The maximum number of results to return in each page.
                                                                                                                                                                                                                                        	MaxResults *int32
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Identifies the next page of results to return.
                                                                                                                                                                                                                                        	NextToken *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ListPiiEntitiesDetectionJobsOutput

                                                                                                                                                                                                                                        type ListPiiEntitiesDetectionJobsOutput struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Identifies the next page of results to return.
                                                                                                                                                                                                                                        	NextToken *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// A list containing the properties of each job that is returned.
                                                                                                                                                                                                                                        	PiiEntitiesDetectionJobPropertiesList []types.PiiEntitiesDetectionJobProperties
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        type ListSentimentDetectionJobsAPIClient

                                                                                                                                                                                                                                        type ListSentimentDetectionJobsAPIClient interface {
                                                                                                                                                                                                                                        	ListSentimentDetectionJobs(context.Context, *ListSentimentDetectionJobsInput, ...func(*Options)) (*ListSentimentDetectionJobsOutput, error)
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          ListSentimentDetectionJobsAPIClient is a client that implements the ListSentimentDetectionJobs operation.

                                                                                                                                                                                                                                          type ListSentimentDetectionJobsInput

                                                                                                                                                                                                                                          type ListSentimentDetectionJobsInput struct {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// Filters the jobs that are returned. You can filter jobs on their name, status,
                                                                                                                                                                                                                                          	// or the date and time that they were submitted. You can only set one filter at a
                                                                                                                                                                                                                                          	// time.
                                                                                                                                                                                                                                          	Filter *types.SentimentDetectionJobFilter
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                                                                          	MaxResults *int32
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// Identifies the next page of results to return.
                                                                                                                                                                                                                                          	NextToken *string
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                          type ListSentimentDetectionJobsOutput

                                                                                                                                                                                                                                          type ListSentimentDetectionJobsOutput struct {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// Identifies the next page of results to return.
                                                                                                                                                                                                                                          	NextToken *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// A list containing the properties of each job that is returned.
                                                                                                                                                                                                                                          	SentimentDetectionJobPropertiesList []types.SentimentDetectionJobProperties
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                          type ListSentimentDetectionJobsPaginator

                                                                                                                                                                                                                                          type ListSentimentDetectionJobsPaginator struct {
                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            ListSentimentDetectionJobsPaginator is a paginator for ListSentimentDetectionJobs

                                                                                                                                                                                                                                            func NewListSentimentDetectionJobsPaginator

                                                                                                                                                                                                                                              NewListSentimentDetectionJobsPaginator returns a new ListSentimentDetectionJobsPaginator

                                                                                                                                                                                                                                              func (*ListSentimentDetectionJobsPaginator) HasMorePages

                                                                                                                                                                                                                                              func (p *ListSentimentDetectionJobsPaginator) HasMorePages() bool

                                                                                                                                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                                                                func (*ListSentimentDetectionJobsPaginator) NextPage

                                                                                                                                                                                                                                                  NextPage retrieves the next ListSentimentDetectionJobs page.

                                                                                                                                                                                                                                                  type ListSentimentDetectionJobsPaginatorOptions

                                                                                                                                                                                                                                                  type ListSentimentDetectionJobsPaginatorOptions struct {
                                                                                                                                                                                                                                                  	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                                                                                  	Limit int32
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                                                                  	// that matches the most recent token provided to the service.
                                                                                                                                                                                                                                                  	StopOnDuplicateToken bool
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    ListSentimentDetectionJobsPaginatorOptions is the paginator options for ListSentimentDetectionJobs

                                                                                                                                                                                                                                                    type ListTagsForResourceInput

                                                                                                                                                                                                                                                    type ListTagsForResourceInput struct {
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the given Amazon Comprehend resource you are
                                                                                                                                                                                                                                                    	// querying.
                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                    	ResourceArn *string
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                    type ListTagsForResourceOutput

                                                                                                                                                                                                                                                    type ListTagsForResourceOutput struct {
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the given Amazon Comprehend resource you are
                                                                                                                                                                                                                                                    	// querying.
                                                                                                                                                                                                                                                    	ResourceArn *string
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// Tags associated with the Amazon Comprehend resource being queried. A tag is a
                                                                                                                                                                                                                                                    	// key-value pair that adds as a metadata to a resource used by Amazon Comprehend.
                                                                                                                                                                                                                                                    	// For example, a tag with "Sales" as the key might be added to a resource to
                                                                                                                                                                                                                                                    	// indicate its use by the sales department.
                                                                                                                                                                                                                                                    	Tags []types.Tag
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                    type ListTopicsDetectionJobsAPIClient

                                                                                                                                                                                                                                                    type ListTopicsDetectionJobsAPIClient interface {
                                                                                                                                                                                                                                                    	ListTopicsDetectionJobs(context.Context, *ListTopicsDetectionJobsInput, ...func(*Options)) (*ListTopicsDetectionJobsOutput, error)
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      ListTopicsDetectionJobsAPIClient is a client that implements the ListTopicsDetectionJobs operation.

                                                                                                                                                                                                                                                      type ListTopicsDetectionJobsInput

                                                                                                                                                                                                                                                      type ListTopicsDetectionJobsInput struct {
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Filters the jobs that are returned. Jobs can be filtered on their name, status,
                                                                                                                                                                                                                                                      	// or the date and time that they were submitted. You can set only one filter at a
                                                                                                                                                                                                                                                      	// time.
                                                                                                                                                                                                                                                      	Filter *types.TopicsDetectionJobFilter
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                                                                                      	MaxResults *int32
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Identifies the next page of results to return.
                                                                                                                                                                                                                                                      	NextToken *string
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                      type ListTopicsDetectionJobsOutput

                                                                                                                                                                                                                                                      type ListTopicsDetectionJobsOutput struct {
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Identifies the next page of results to return.
                                                                                                                                                                                                                                                      	NextToken *string
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// A list containing the properties of each job that is returned.
                                                                                                                                                                                                                                                      	TopicsDetectionJobPropertiesList []types.TopicsDetectionJobProperties
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                      type ListTopicsDetectionJobsPaginator

                                                                                                                                                                                                                                                      type ListTopicsDetectionJobsPaginator struct {
                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        ListTopicsDetectionJobsPaginator is a paginator for ListTopicsDetectionJobs

                                                                                                                                                                                                                                                        func NewListTopicsDetectionJobsPaginator

                                                                                                                                                                                                                                                          NewListTopicsDetectionJobsPaginator returns a new ListTopicsDetectionJobsPaginator

                                                                                                                                                                                                                                                          func (*ListTopicsDetectionJobsPaginator) HasMorePages

                                                                                                                                                                                                                                                          func (p *ListTopicsDetectionJobsPaginator) HasMorePages() bool

                                                                                                                                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                                                                                                                            func (*ListTopicsDetectionJobsPaginator) NextPage

                                                                                                                                                                                                                                                              NextPage retrieves the next ListTopicsDetectionJobs page.

                                                                                                                                                                                                                                                              type ListTopicsDetectionJobsPaginatorOptions

                                                                                                                                                                                                                                                              type ListTopicsDetectionJobsPaginatorOptions struct {
                                                                                                                                                                                                                                                              	// The maximum number of results to return in each page. The default is 100.
                                                                                                                                                                                                                                                              	Limit int32
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// Set to true if pagination should stop if the service returns a pagination token
                                                                                                                                                                                                                                                              	// that matches the most recent token provided to the service.
                                                                                                                                                                                                                                                              	StopOnDuplicateToken bool
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                ListTopicsDetectionJobsPaginatorOptions is the paginator options for ListTopicsDetectionJobs

                                                                                                                                                                                                                                                                type Options

                                                                                                                                                                                                                                                                type Options struct {
                                                                                                                                                                                                                                                                	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                                                                                                                                                                                	// operations invoked for this client. Use functional options on operation call to
                                                                                                                                                                                                                                                                	// modify this list for per operation behavior.
                                                                                                                                                                                                                                                                	APIOptions []func(*middleware.Stack) error
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// Configures the events that will be sent to the configured logger.
                                                                                                                                                                                                                                                                	ClientLogMode aws.ClientLogMode
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The credentials object to use when signing requests.
                                                                                                                                                                                                                                                                	Credentials aws.CredentialsProvider
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                                                                                                                                                                                	EndpointOptions EndpointResolverOptions
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The service endpoint resolver.
                                                                                                                                                                                                                                                                	EndpointResolver EndpointResolver
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// Signature Version 4 (SigV4) Signer
                                                                                                                                                                                                                                                                	HTTPSignerV4 HTTPSignerV4
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// Provides idempotency tokens values that will be automatically populated into
                                                                                                                                                                                                                                                                	// idempotent API operations.
                                                                                                                                                                                                                                                                	IdempotencyTokenProvider IdempotencyTokenProvider
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The logger writer interface to write logging messages to.
                                                                                                                                                                                                                                                                	Logger logging.Logger
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The region to send requests to. (Required)
                                                                                                                                                                                                                                                                	Region string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                                                                                                                                                                                	// failures. When nil the API client will use a default retryer.
                                                                                                                                                                                                                                                                	Retryer aws.Retryer
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                                                                                                                                                                                	// implementation if nil.
                                                                                                                                                                                                                                                                	HTTPClient HTTPClient
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                func (Options) Copy

                                                                                                                                                                                                                                                                func (o Options) Copy() Options

                                                                                                                                                                                                                                                                  Copy creates a clone where the APIOptions list is deep copied.

                                                                                                                                                                                                                                                                  type ResolveEndpoint

                                                                                                                                                                                                                                                                  type ResolveEndpoint struct {
                                                                                                                                                                                                                                                                  	Resolver EndpointResolver
                                                                                                                                                                                                                                                                  	Options  EndpointResolverOptions
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  func (*ResolveEndpoint) HandleSerialize

                                                                                                                                                                                                                                                                  func (*ResolveEndpoint) ID

                                                                                                                                                                                                                                                                  func (*ResolveEndpoint) ID() string

                                                                                                                                                                                                                                                                  type StartDocumentClassificationJobInput

                                                                                                                                                                                                                                                                  type StartDocumentClassificationJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                                                                                                  	// role that grants Amazon Comprehend read access to your input data.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DataAccessRoleArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the document classifier to use to process the
                                                                                                                                                                                                                                                                  	// job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DocumentClassifierArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies the format and location of the input data for the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	InputDataConfig *types.InputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies where to send the output files.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	OutputDataConfig *types.OutputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A unique identifier for the request. If you do not set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the job.
                                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                                                                                                                                                  	// encrypt data on the storage volume attached to the ML compute instance(s) that
                                                                                                                                                                                                                                                                  	// process the analysis job. The VolumeKmsKeyId can be either of the following
                                                                                                                                                                                                                                                                  	// formats:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * Amazon
                                                                                                                                                                                                                                                                  	// Resource Name (ARN) of a KMS Key:
                                                                                                                                                                                                                                                                  	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	VolumeKmsKeyId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Configuration parameters for an optional private Virtual Private Cloud (VPC)
                                                                                                                                                                                                                                                                  	// containing the resources you are using for your document classification job. For
                                                                                                                                                                                                                                                                  	// more information, see Amazon VPC
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).
                                                                                                                                                                                                                                                                  	VpcConfig *types.VpcConfig
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartDocumentClassificationJobOutput

                                                                                                                                                                                                                                                                  type StartDocumentClassificationJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier generated for the job. To get the status of the job, use this
                                                                                                                                                                                                                                                                  	// identifier with the operation.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the job:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * SUBMITTED - The job has been received and queued for
                                                                                                                                                                                                                                                                  	// processing.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * IN_PROGRESS - Amazon Comprehend is processing the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// COMPLETED - The job was successfully completed and the output is available.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// FAILED - The job did not complete. For details, use the operation.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// STOP_REQUESTED - Amazon Comprehend has received a stop request for the job and
                                                                                                                                                                                                                                                                  	// is processing the request.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * STOPPED - The job was successfully stopped without
                                                                                                                                                                                                                                                                  	// completing.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartDominantLanguageDetectionJobInput

                                                                                                                                                                                                                                                                  type StartDominantLanguageDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                                                                                                  	// role that grants Amazon Comprehend read access to your input data. For more
                                                                                                                                                                                                                                                                  	// information, see
                                                                                                                                                                                                                                                                  	// https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions).
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DataAccessRoleArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies the format and location of the input data for the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	InputDataConfig *types.InputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies where to send the output files.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	OutputDataConfig *types.OutputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A unique identifier for the request. If you do not set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// An identifier for the job.
                                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                                                                                                                                                  	// encrypt data on the storage volume attached to the ML compute instance(s) that
                                                                                                                                                                                                                                                                  	// process the analysis job. The VolumeKmsKeyId can be either of the following
                                                                                                                                                                                                                                                                  	// formats:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * Amazon
                                                                                                                                                                                                                                                                  	// Resource Name (ARN) of a KMS Key:
                                                                                                                                                                                                                                                                  	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	VolumeKmsKeyId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Configuration parameters for an optional private Virtual Private Cloud (VPC)
                                                                                                                                                                                                                                                                  	// containing the resources you are using for your dominant language detection job.
                                                                                                                                                                                                                                                                  	// For more information, see Amazon VPC
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).
                                                                                                                                                                                                                                                                  	VpcConfig *types.VpcConfig
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartDominantLanguageDetectionJobOutput

                                                                                                                                                                                                                                                                  type StartDominantLanguageDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier generated for the job. To get the status of a job, use this
                                                                                                                                                                                                                                                                  	// identifier with the operation.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * SUBMITTED - The job has been received and is queued
                                                                                                                                                                                                                                                                  	// for processing.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * IN_PROGRESS - Amazon Comprehend is processing the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// COMPLETED - The job was successfully completed and the output is available.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// FAILED - The job did not complete. To get details, use the operation.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartEntitiesDetectionJobInput

                                                                                                                                                                                                                                                                  type StartEntitiesDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                                                                                                  	// role that grants Amazon Comprehend read access to your input data. For more
                                                                                                                                                                                                                                                                  	// information, see
                                                                                                                                                                                                                                                                  	// https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions).
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DataAccessRoleArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies the format and location of the input data for the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	InputDataConfig *types.InputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The language of the input documents. All documents must be in the same language.
                                                                                                                                                                                                                                                                  	// You can specify any of the languages supported by Amazon Comprehend. If custom
                                                                                                                                                                                                                                                                  	// entities recognition is used, this parameter is ignored and the language used
                                                                                                                                                                                                                                                                  	// for training the model is used instead.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	LanguageCode types.LanguageCode
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies where to send the output files.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	OutputDataConfig *types.OutputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A unique identifier for the request. If you don't set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) that identifies the specific entity recognizer to
                                                                                                                                                                                                                                                                  	// be used by the StartEntitiesDetectionJob. This ARN is optional and is only used
                                                                                                                                                                                                                                                                  	// for a custom entity recognition job.
                                                                                                                                                                                                                                                                  	EntityRecognizerArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the job.
                                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                                                                                                                                                  	// encrypt data on the storage volume attached to the ML compute instance(s) that
                                                                                                                                                                                                                                                                  	// process the analysis job. The VolumeKmsKeyId can be either of the following
                                                                                                                                                                                                                                                                  	// formats:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * Amazon
                                                                                                                                                                                                                                                                  	// Resource Name (ARN) of a KMS Key:
                                                                                                                                                                                                                                                                  	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	VolumeKmsKeyId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Configuration parameters for an optional private Virtual Private Cloud (VPC)
                                                                                                                                                                                                                                                                  	// containing the resources you are using for your entity detection job. For more
                                                                                                                                                                                                                                                                  	// information, see Amazon VPC
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).
                                                                                                                                                                                                                                                                  	VpcConfig *types.VpcConfig
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartEntitiesDetectionJobOutput

                                                                                                                                                                                                                                                                  type StartEntitiesDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier generated for the job. To get the status of job, use this
                                                                                                                                                                                                                                                                  	// identifier with the operation.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * SUBMITTED - The job has been received and is queued
                                                                                                                                                                                                                                                                  	// for processing.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * IN_PROGRESS - Amazon Comprehend is processing the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// COMPLETED - The job was successfully completed and the output is available.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// FAILED - The job did not complete. To get details, use the operation.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// STOP_REQUESTED - Amazon Comprehend has received a stop request for the job and
                                                                                                                                                                                                                                                                  	// is processing the request.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * STOPPED - The job was successfully stopped without
                                                                                                                                                                                                                                                                  	// completing.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartEventsDetectionJobInput

                                                                                                                                                                                                                                                                  type StartEventsDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                                                                                                  	// role that grants Amazon Comprehend read access to your input data.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DataAccessRoleArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies the format and location of the input data for the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	InputDataConfig *types.InputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The language code of the input documents.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	LanguageCode types.LanguageCode
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies where to send the output files.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	OutputDataConfig *types.OutputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The types of events to detect in the input documents.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	TargetEventTypes []string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// An unique identifier for the request. If you don't set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the events detection job.
                                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartEventsDetectionJobOutput

                                                                                                                                                                                                                                                                  type StartEventsDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// An unique identifier for the request. If you don't set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the events detection job.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartKeyPhrasesDetectionJobInput

                                                                                                                                                                                                                                                                  type StartKeyPhrasesDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                                                                                                  	// role that grants Amazon Comprehend read access to your input data. For more
                                                                                                                                                                                                                                                                  	// information, see
                                                                                                                                                                                                                                                                  	// https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions).
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DataAccessRoleArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies the format and location of the input data for the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	InputDataConfig *types.InputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The language of the input documents. You can specify any of the primary
                                                                                                                                                                                                                                                                  	// languages supported by Amazon Comprehend. All documents must be in the same
                                                                                                                                                                                                                                                                  	// language.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	LanguageCode types.LanguageCode
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies where to send the output files.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	OutputDataConfig *types.OutputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A unique identifier for the request. If you don't set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the job.
                                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                                                                                                                                                  	// encrypt data on the storage volume attached to the ML compute instance(s) that
                                                                                                                                                                                                                                                                  	// process the analysis job. The VolumeKmsKeyId can be either of the following
                                                                                                                                                                                                                                                                  	// formats:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * Amazon
                                                                                                                                                                                                                                                                  	// Resource Name (ARN) of a KMS Key:
                                                                                                                                                                                                                                                                  	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	VolumeKmsKeyId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Configuration parameters for an optional private Virtual Private Cloud (VPC)
                                                                                                                                                                                                                                                                  	// containing the resources you are using for your key phrases detection job. For
                                                                                                                                                                                                                                                                  	// more information, see Amazon VPC
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).
                                                                                                                                                                                                                                                                  	VpcConfig *types.VpcConfig
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartKeyPhrasesDetectionJobOutput

                                                                                                                                                                                                                                                                  type StartKeyPhrasesDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier generated for the job. To get the status of a job, use this
                                                                                                                                                                                                                                                                  	// identifier with the operation.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * SUBMITTED - The job has been received and is queued
                                                                                                                                                                                                                                                                  	// for processing.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * IN_PROGRESS - Amazon Comprehend is processing the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// COMPLETED - The job was successfully completed and the output is available.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// FAILED - The job did not complete. To get details, use the operation.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartPiiEntitiesDetectionJobInput

                                                                                                                                                                                                                                                                  type StartPiiEntitiesDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                                                                                                  	// role that grants Amazon Comprehend read access to your input data.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DataAccessRoleArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The input properties for a PII entities detection job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	InputDataConfig *types.InputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The language of the input documents.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	LanguageCode types.LanguageCode
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies whether the output provides the locations (offsets) of PII entities or
                                                                                                                                                                                                                                                                  	// a file in which PII entities are redacted.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	Mode types.PiiEntitiesDetectionMode
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Provides configuration parameters for the output of PII entity detection jobs.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	OutputDataConfig *types.OutputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A unique identifier for the request. If you don't set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the job.
                                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Provides configuration parameters for PII entity redaction. This parameter is
                                                                                                                                                                                                                                                                  	// required if you set the Mode parameter to ONLY_REDACTION. In that case, you must
                                                                                                                                                                                                                                                                  	// provide a RedactionConfig definition that includes the PiiEntityTypes parameter.
                                                                                                                                                                                                                                                                  	RedactionConfig *types.RedactionConfig
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartPiiEntitiesDetectionJobOutput

                                                                                                                                                                                                                                                                  type StartPiiEntitiesDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier generated for the job.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the job.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartSentimentDetectionJobInput

                                                                                                                                                                                                                                                                  type StartSentimentDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                                                                                                  	// role that grants Amazon Comprehend read access to your input data. For more
                                                                                                                                                                                                                                                                  	// information, see
                                                                                                                                                                                                                                                                  	// https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions).
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DataAccessRoleArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies the format and location of the input data for the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	InputDataConfig *types.InputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The language of the input documents. You can specify any of the primary
                                                                                                                                                                                                                                                                  	// languages supported by Amazon Comprehend. All documents must be in the same
                                                                                                                                                                                                                                                                  	// language.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	LanguageCode types.LanguageCode
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies where to send the output files.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	OutputDataConfig *types.OutputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A unique identifier for the request. If you don't set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the job.
                                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                                                                                                                                                  	// encrypt data on the storage volume attached to the ML compute instance(s) that
                                                                                                                                                                                                                                                                  	// process the analysis job. The VolumeKmsKeyId can be either of the following
                                                                                                                                                                                                                                                                  	// formats:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * Amazon
                                                                                                                                                                                                                                                                  	// Resource Name (ARN) of a KMS Key:
                                                                                                                                                                                                                                                                  	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	VolumeKmsKeyId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Configuration parameters for an optional private Virtual Private Cloud (VPC)
                                                                                                                                                                                                                                                                  	// containing the resources you are using for your sentiment detection job. For
                                                                                                                                                                                                                                                                  	// more information, see Amazon VPC
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).
                                                                                                                                                                                                                                                                  	VpcConfig *types.VpcConfig
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartSentimentDetectionJobOutput

                                                                                                                                                                                                                                                                  type StartSentimentDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier generated for the job. To get the status of a job, use this
                                                                                                                                                                                                                                                                  	// identifier with the operation.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * SUBMITTED - The job has been received and is queued
                                                                                                                                                                                                                                                                  	// for processing.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * IN_PROGRESS - Amazon Comprehend is processing the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// COMPLETED - The job was successfully completed and the output is available.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// FAILED - The job did not complete. To get details, use the operation.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartTopicsDetectionJobInput

                                                                                                                                                                                                                                                                  type StartTopicsDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM)
                                                                                                                                                                                                                                                                  	// role that grants Amazon Comprehend read access to your input data. For more
                                                                                                                                                                                                                                                                  	// information, see
                                                                                                                                                                                                                                                                  	// https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/comprehend/latest/dg/access-control-managing-permissions.html#auth-role-permissions).
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DataAccessRoleArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies the format and location of the input data for the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	InputDataConfig *types.InputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Specifies where to send the output files. The output is a compressed archive
                                                                                                                                                                                                                                                                  	// with two files, topic-terms.csv that lists the terms associated with each topic,
                                                                                                                                                                                                                                                                  	// and doc-topics.csv that lists the documents associated with each topic
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	OutputDataConfig *types.OutputDataConfig
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// A unique identifier for the request. If you do not set the client request token,
                                                                                                                                                                                                                                                                  	// Amazon Comprehend generates one.
                                                                                                                                                                                                                                                                  	ClientRequestToken *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the job.
                                                                                                                                                                                                                                                                  	JobName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The number of topics to detect.
                                                                                                                                                                                                                                                                  	NumberOfTopics *int32
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// ID for the AWS Key Management Service (KMS) key that Amazon Comprehend uses to
                                                                                                                                                                                                                                                                  	// encrypt data on the storage volume attached to the ML compute instance(s) that
                                                                                                                                                                                                                                                                  	// process the analysis job. The VolumeKmsKeyId can be either of the following
                                                                                                                                                                                                                                                                  	// formats:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * KMS Key ID: "1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * Amazon
                                                                                                                                                                                                                                                                  	// Resource Name (ARN) of a KMS Key:
                                                                                                                                                                                                                                                                  	// "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
                                                                                                                                                                                                                                                                  	VolumeKmsKeyId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Configuration parameters for an optional private Virtual Private Cloud (VPC)
                                                                                                                                                                                                                                                                  	// containing the resources you are using for your topic detection job. For more
                                                                                                                                                                                                                                                                  	// information, see Amazon VPC
                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html).
                                                                                                                                                                                                                                                                  	VpcConfig *types.VpcConfig
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StartTopicsDetectionJobOutput

                                                                                                                                                                                                                                                                  type StartTopicsDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier generated for the job. To get the status of the job, use this
                                                                                                                                                                                                                                                                  	// identifier with the DescribeTopicDetectionJob operation.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the job:
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * SUBMITTED - The job has been received and is queued
                                                                                                                                                                                                                                                                  	// for processing.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// * IN_PROGRESS - Amazon Comprehend is processing the job.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// COMPLETED - The job was successfully completed and the output is available.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// *
                                                                                                                                                                                                                                                                  	// FAILED - The job did not complete. To get details, use the
                                                                                                                                                                                                                                                                  	// DescribeTopicDetectionJob operation.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopDominantLanguageDetectionJobInput

                                                                                                                                                                                                                                                                  type StopDominantLanguageDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the dominant language detection job to stop.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopDominantLanguageDetectionJobOutput

                                                                                                                                                                                                                                                                  type StopDominantLanguageDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the dominant language detection job to stop.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Either STOP_REQUESTED if the job is currently running, or STOPPED if the job was
                                                                                                                                                                                                                                                                  	// previously stopped with the StopDominantLanguageDetectionJob operation.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopEntitiesDetectionJobInput

                                                                                                                                                                                                                                                                  type StopEntitiesDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the entities detection job to stop.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopEntitiesDetectionJobOutput

                                                                                                                                                                                                                                                                  type StopEntitiesDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the entities detection job to stop.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Either STOP_REQUESTED if the job is currently running, or STOPPED if the job was
                                                                                                                                                                                                                                                                  	// previously stopped with the StopEntitiesDetectionJob operation.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopEventsDetectionJobInput

                                                                                                                                                                                                                                                                  type StopEventsDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the events detection job to stop.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopEventsDetectionJobOutput

                                                                                                                                                                                                                                                                  type StopEventsDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the events detection job to stop.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the events detection job.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopKeyPhrasesDetectionJobInput

                                                                                                                                                                                                                                                                  type StopKeyPhrasesDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the key phrases detection job to stop.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopKeyPhrasesDetectionJobOutput

                                                                                                                                                                                                                                                                  type StopKeyPhrasesDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the key phrases detection job to stop.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Either STOP_REQUESTED if the job is currently running, or STOPPED if the job was
                                                                                                                                                                                                                                                                  	// previously stopped with the StopKeyPhrasesDetectionJob operation.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopPiiEntitiesDetectionJobInput

                                                                                                                                                                                                                                                                  type StopPiiEntitiesDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the PII entities detection job to stop.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopPiiEntitiesDetectionJobOutput

                                                                                                                                                                                                                                                                  type StopPiiEntitiesDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the PII entities detection job to stop.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The status of the PII entities detection job.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopSentimentDetectionJobInput

                                                                                                                                                                                                                                                                  type StopSentimentDetectionJobInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the sentiment detection job to stop.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopSentimentDetectionJobOutput

                                                                                                                                                                                                                                                                  type StopSentimentDetectionJobOutput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the sentiment detection job to stop.
                                                                                                                                                                                                                                                                  	JobId *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Either STOP_REQUESTED if the job is currently running, or STOPPED if the job was
                                                                                                                                                                                                                                                                  	// previously stopped with the StopSentimentDetectionJob operation.
                                                                                                                                                                                                                                                                  	JobStatus types.JobStatus
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopTrainingDocumentClassifierInput

                                                                                                                                                                                                                                                                  type StopTrainingDocumentClassifierInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) that identifies the document classifier currently
                                                                                                                                                                                                                                                                  	// being trained.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DocumentClassifierArn *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopTrainingDocumentClassifierOutput

                                                                                                                                                                                                                                                                  type StopTrainingDocumentClassifierOutput struct {
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopTrainingEntityRecognizerInput

                                                                                                                                                                                                                                                                  type StopTrainingEntityRecognizerInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) that identifies the entity recognizer currently
                                                                                                                                                                                                                                                                  	// being trained.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	EntityRecognizerArn *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type StopTrainingEntityRecognizerOutput

                                                                                                                                                                                                                                                                  type StopTrainingEntityRecognizerOutput struct {
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type TagResourceInput

                                                                                                                                                                                                                                                                  type TagResourceInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the given Amazon Comprehend resource to which
                                                                                                                                                                                                                                                                  	// you want to associate the tags.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	ResourceArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Tags being associated with a specific Amazon Comprehend resource. There can be a
                                                                                                                                                                                                                                                                  	// maximum of 50 tags (both existing and pending) associated with a specific
                                                                                                                                                                                                                                                                  	// resource.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	Tags []types.Tag
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type TagResourceOutput

                                                                                                                                                                                                                                                                  type TagResourceOutput struct {
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type UntagResourceInput

                                                                                                                                                                                                                                                                  type UntagResourceInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the given Amazon Comprehend resource from
                                                                                                                                                                                                                                                                  	// which you want to remove the tags.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	ResourceArn *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The initial part of a key-value pair that forms a tag being removed from a given
                                                                                                                                                                                                                                                                  	// resource. For example, a tag with "Sales" as the key might be added to a
                                                                                                                                                                                                                                                                  	// resource to indicate its use by the sales department. Keys must be unique and
                                                                                                                                                                                                                                                                  	// cannot be duplicated for a particular resource.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	TagKeys []string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type UntagResourceOutput

                                                                                                                                                                                                                                                                  type UntagResourceOutput struct {
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type UpdateEndpointInput

                                                                                                                                                                                                                                                                  type UpdateEndpointInput struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The desired number of inference units to be used by the model using this
                                                                                                                                                                                                                                                                  	// endpoint. Each inference unit represents of a throughput of 100 characters per
                                                                                                                                                                                                                                                                  	// second.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DesiredInferenceUnits *int32
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The Amazon Resource Number (ARN) of the endpoint being updated.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	EndpointArn *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type UpdateEndpointOutput

                                                                                                                                                                                                                                                                  type UpdateEndpointOutput struct {
                                                                                                                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  Source Files

                                                                                                                                                                                                                                                                  Directories

                                                                                                                                                                                                                                                                  Path Synopsis
                                                                                                                                                                                                                                                                  internal